diff --git a/Content.Client/Guidebook/Controls/GuideMicrowaveEmbed.xaml.cs b/Content.Client/Guidebook/Controls/GuideMicrowaveEmbed.xaml.cs
index e54892d634..5eb654f8ee 100644
--- a/Content.Client/Guidebook/Controls/GuideMicrowaveEmbed.xaml.cs
+++ b/Content.Client/Guidebook/Controls/GuideMicrowaveEmbed.xaml.cs
@@ -39,10 +39,10 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
 
     public GuideMicrowaveEmbed(string recipe) : this()
     {
-        GenerateControl(_prototype.Index<FoodRecipePrototype>(recipe));
+        GenerateControl(_prototype.Index<MicrowaveMealRecipePrototype>(recipe));
     }
 
-    public GuideMicrowaveEmbed(FoodRecipePrototype recipe) : this()
+    public GuideMicrowaveEmbed(MicrowaveMealRecipePrototype recipe) : this()
     {
         GenerateControl(recipe);
     }
@@ -66,7 +66,7 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
             return false;
         }
 
-        if (!_prototype.TryIndex<FoodRecipePrototype>(id, out var recipe))
+        if (!_prototype.TryIndex<MicrowaveMealRecipePrototype>(id, out var recipe))
         {
             _sawmill.Error($"Specified recipe prototype \"{id}\" is not a valid recipe prototype");
             return false;
@@ -78,7 +78,7 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
         return true;
     }
 
-    private void GenerateHeader(FoodRecipePrototype recipe)
+    private void GenerateHeader(MicrowaveMealRecipePrototype recipe)
     {
         var entity = _prototype.Index<EntityPrototype>(recipe.Result);
 
@@ -89,9 +89,9 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
         ResultDescription.SetMarkup(entity.Description);
     }
 
-    private void GenerateSolidIngredients(FoodRecipePrototype recipe)
+    private void GenerateSolidIngredients(MicrowaveMealRecipePrototype recipe)
     {
-        foreach (var (product, amount) in recipe.IngredientsSolids.OrderByDescending(p => p.Value))
+        foreach (var (product, amount) in recipe.Ingredients.Solids.OrderByDescending(p => p.Value))
         {
             var ingredient = _prototype.Index<EntityPrototype>(product);
 
@@ -122,9 +122,9 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
         }
     }
 
-    private void GenerateLiquidIngredients(FoodRecipePrototype recipe)
+    private void GenerateLiquidIngredients(MicrowaveMealRecipePrototype recipe)
     {
-        foreach (var (product, amount) in recipe.IngredientsReagents.OrderByDescending(p => p.Value))
+        foreach (var (product, amount) in recipe.Ingredients.Reagents.OrderByDescending(p => p.Value))
         {
             var reagent = _prototype.Index<ReagentPrototype>(product);
 
@@ -165,22 +165,58 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
         }
     }
 
-    private void GenerateIngredients(FoodRecipePrototype recipe)
+    private void GenerateStackIngredients(MicrowaveMealRecipePrototype recipe)
+    {
+        foreach (var (product, amount) in recipe.Ingredients.Stacks.OrderByDescending(p => p.Value))
+        {
+            var stack = _prototype.Index(product);
+
+            // stack icon
+
+            IngredientsGrid.AddChild(new GuideEntityEmbed(stack.Spawn, false, false));
+
+            // stack name
+
+            var stackName = Loc.GetString(stack.Name);
+            var stackNameMsg = new FormattedMessage();
+            stackNameMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-stack-name-display", ("stack", stackName)));
+            stackNameMsg.Pop();
+
+            var stackNameLabel = new RichTextLabel();
+            stackNameLabel.SetMessage(stackNameMsg);
+
+            IngredientsGrid.AddChild(stackNameLabel);
+
+            // stack quantity
+
+            var stackQuantityMsg = new FormattedMessage();
+            stackQuantityMsg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-stack-quantity-display", ("amount", amount)));
+            stackQuantityMsg.Pop();
+
+            var stackQuantityLabel = new RichTextLabel();
+            stackQuantityLabel.SetMessage(stackQuantityMsg);
+
+            IngredientsGrid.AddChild(stackQuantityLabel);
+        }
+    }
+
+    private void GenerateIngredients(MicrowaveMealRecipePrototype recipe)
     {
         GenerateLiquidIngredients(recipe);
+        GenerateStackIngredients(recipe);
         GenerateSolidIngredients(recipe);
     }
 
-    private void GenerateCookTime(FoodRecipePrototype recipe)
+    private void GenerateCookTime(MicrowaveMealRecipePrototype recipe)
     {
         var msg = new FormattedMessage();
-        msg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-cook-time", ("time", recipe.CookTime)));
+        msg.AddMarkupOrThrow(Loc.GetString("guidebook-microwave-cook-time", ("time", recipe.Time)));
         msg.Pop();
 
         CookTimeLabel.SetMessage(msg);
     }
 
-    private void GenerateControl(FoodRecipePrototype recipe)
+    private void GenerateControl(MicrowaveMealRecipePrototype recipe)
     {
         GenerateHeader(recipe);
         GenerateIngredients(recipe);
diff --git a/Content.Client/Guidebook/Controls/GuideMicrowaveGroupEmbed.cs b/Content.Client/Guidebook/Controls/GuideMicrowaveGroupEmbed.cs
index 9fe70faaaa..584a2c3387 100644
--- a/Content.Client/Guidebook/Controls/GuideMicrowaveGroupEmbed.cs
+++ b/Content.Client/Guidebook/Controls/GuideMicrowaveGroupEmbed.cs
@@ -50,7 +50,7 @@ public sealed partial class GuideMicrowaveGroupEmbed : BoxContainer, IDocumentTa
 
     private void CreateEntries(string group)
     {
-        var prototypes = _prototype.EnumeratePrototypes<FoodRecipePrototype>()
+        var prototypes = _prototype.EnumeratePrototypes<MicrowaveMealRecipePrototype>()
             .Where(p => p.Group.Equals(group))
             .OrderBy(p => p.Name);
 
diff --git a/Content.Client/Kitchen/EntitySystems/ClientMicrowaveSystem.cs b/Content.Client/Kitchen/EntitySystems/ClientMicrowaveSystem.cs
new file mode 100644
index 0000000000..c2203b790b
--- /dev/null
+++ b/Content.Client/Kitchen/EntitySystems/ClientMicrowaveSystem.cs
@@ -0,0 +1,52 @@
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Kitchen.EntitySystems;
+using Robust.Client.Player;
+
+namespace Content.Client.Kitchen.EntitySystems;
+
+/// <inheritdoc />
+public sealed partial class ClientMicrowaveSystem : MicrowaveSystem
+{
+    [Dependency] private IPlayerManager _player = default!;
+    [Dependency] private SharedUserInterfaceSystem _userInterface = default!;
+
+    public override void UpdateUI(Entity<MicrowaveComponent?> microwave)
+    {
+        base.UpdateUI(microwave);
+
+        if (!MicrowaveQuery.Resolve(microwave.Owner, ref microwave.Comp))
+            return;
+
+        if (_userInterface.TryGetOpenUi(microwave.Owner, MicrowaveUiKey.Key, out var bui))
+            bui.Update();
+    }
+
+    protected override void ActivateMicrowaveCycle(Entity<MicrowaveComponent> ent)
+    {
+        base.ActivateMicrowaveCycle(ent);
+
+        if (!Timing.IsFirstTimePredicted)
+            return;
+
+        var audioParams = ent.Comp.LoopingSound.Params;
+        audioParams = audioParams.WithLoop(true).WithMaxDistance(5);
+
+        ent.Comp.PlayingStream ??= Audio.PlayLocal(ent.Comp.LoopingSound, ent, _player.LocalEntity, audioParams)?.Entity;
+    }
+
+    protected override void DeactivateMicrowaveCycle(Entity<MicrowaveComponent> ent)
+    {
+        base.DeactivateMicrowaveCycle(ent);
+
+        // We have this check here so Audio.Stop doesn't mistakenly tell us that the entity has been deleted when it hasn't been!!!
+        if (!Timing.IsFirstTimePredicted)
+            return;
+
+        ent.Comp.PlayingStream = Audio.Stop(ent.Comp.PlayingStream);
+
+        foreach (var solid in GetMicrowaveContents(ent.AsNullable()))
+        {
+            RemComp<ActivelyMicrowavedComponent>(solid);
+        }
+    }
+}
diff --git a/Content.Client/Kitchen/UI/MicrowaveBoundUserInterface.cs b/Content.Client/Kitchen/UI/MicrowaveBoundUserInterface.cs
index 643ac47054..2bd63e123b 100644
--- a/Content.Client/Kitchen/UI/MicrowaveBoundUserInterface.cs
+++ b/Content.Client/Kitchen/UI/MicrowaveBoundUserInterface.cs
@@ -1,151 +1,128 @@
-using Content.Shared.Chemistry.Reagent;
 using Content.Shared.Kitchen.Components;
+using Content.Shared.Kitchen.EntitySystems;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Shared.Timing;
 
-namespace Content.Client.Kitchen.UI
+namespace Content.Client.Kitchen.UI;
+
+[UsedImplicitly]
+public sealed partial class MicrowaveBoundUserInterface(EntityUid owner, Enum uiKey) : BoundUserInterface(owner, uiKey)
 {
-    [UsedImplicitly]
-    public sealed class MicrowaveBoundUserInterface : BoundUserInterface
+    [Dependency] private SpriteSystem _sprite = default!;
+    [Dependency] private MicrowaveSystem _microwave = default!;
+
+    [ViewVariables]
+    private MicrowaveMenu? _menu;
+
+    [ViewVariables]
+    private readonly Dictionary<int, EntityUid> _solids = new();
+
+    protected override void Open()
     {
-        [ViewVariables]
-        private MicrowaveMenu? _menu;
+        base.Open();
 
-        [ViewVariables]
-        private readonly Dictionary<int, EntityUid> _solids = new();
-
-        [ViewVariables]
-        private readonly Dictionary<int, ReagentQuantity> _reagents = new();
-
-        public MicrowaveBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+        _menu = this.CreateWindow<MicrowaveMenu>();
+        _menu.StartButton.OnPressed += _ => SendPredictedMessage(new MicrowaveStartCookMessage());
+        _menu.EjectButton.OnPressed += _ => SendPredictedMessage(new MicrowaveEjectMessage());
+        _menu.IngredientsList.OnItemSelected += args =>
         {
-        }
+            SendPredictedMessage(new MicrowaveEjectSolidIndexedMessage(EntMan.GetNetEntity(_solids[args.ItemIndex])));
+        };
 
-        protected override void Open()
+        _menu.OnCookTimeSelected += (name, index, cookTime) =>
         {
-            base.Open();
-            _menu = this.CreateWindow<MicrowaveMenu>();
-            _menu.StartButton.OnPressed += _ => SendPredictedMessage(new MicrowaveStartCookMessage());
-            _menu.EjectButton.OnPressed += _ => SendPredictedMessage(new MicrowaveEjectMessage());
-            _menu.IngredientsList.OnItemSelected += args =>
-            {
-                SendPredictedMessage(new MicrowaveEjectSolidIndexedMessage(EntMan.GetNetEntity(_solids[args.ItemIndex])));
-            };
-
-            _menu.OnCookTimeSelected += (args, buttonIndex) =>
-            {
-                var selectedCookTime = (uint) 0;
-
-                if (args.Button is MicrowaveMenu.MicrowaveCookTimeButton microwaveCookTimeButton)
-                {
-                    // args.Button is a MicrowaveCookTimeButton
-                    var actualButton = (MicrowaveMenu.MicrowaveCookTimeButton) args.Button;
-                    selectedCookTime = actualButton.CookTime == 0 ? 0 : actualButton.CookTime;
-                    // SendMessage(new MicrowaveSelectCookTimeMessage((int) selectedCookTime / 5, actualButton.CookTime));
-                    SendPredictedMessage(new MicrowaveSelectCookTimeMessage((int) selectedCookTime / 5, actualButton.CookTime));
-
-                    _menu.CookTimeInfoLabel.Text = Loc.GetString("microwave-bound-user-interface-cook-time-label",
-                                                                    ("time", selectedCookTime));
-                }
-                else
-                {
-                    // args.Button is a normal button aka instant cook button
-                    SendPredictedMessage(new MicrowaveSelectCookTimeMessage((int) selectedCookTime, 0));
-
-                    _menu.CookTimeInfoLabel.Text = Loc.GetString("microwave-bound-user-interface-cook-time-label",
-                                                         ("time", Loc.GetString("microwave-menu-instant-button")));
-                }
-            };
-        }
-
-        protected override void UpdateState(BoundUserInterfaceState state)
-        {
-            base.UpdateState(state);
-            if (state is not MicrowaveUpdateUserInterfaceState cState || _menu == null)
-            {
-                return;
-            }
-
-            _menu.IsBusy = cState.IsMicrowaveBusy;
-            _menu.CurrentCooktimeEnd = cState.CurrentCookTimeEnd;
-
-            _menu.ToggleBusyDisableOverlayPanel(cState.IsMicrowaveBusy || cState.ContainedSolids.Length == 0);
-            // TODO move this to a component state and ensure the net ids.
-            RefreshContentsDisplay(EntMan.GetEntityArray(cState.ContainedSolids));
-
-            //Set the cook time info label
-            var cookTime = cState.ActiveButtonIndex == 0
-                ? Loc.GetString("microwave-menu-instant-button")
-                : cState.CurrentCookTime.ToString();
-
-
+            SendPredictedMessage(new MicrowaveSelectCookTimeMessage(index, cookTime));
             _menu.CookTimeInfoLabel.Text = Loc.GetString("microwave-bound-user-interface-cook-time-label",
-                                                         ("time", cookTime));
-            _menu.StartButton.Disabled = cState.IsMicrowaveBusy || cState.ContainedSolids.Length == 0;
-            _menu.EjectButton.Disabled = cState.IsMicrowaveBusy || cState.ContainedSolids.Length == 0;
+                ("time", name));
+        };
 
+        Update();
+    }
 
-            //Set the correct button active button
-            if (cState.ActiveButtonIndex == 0)
-            {
-                _menu.InstantCookButton.Pressed = true;
-            }
-            else
-            {
-                var currentlySelectedTimeButton = (Button) _menu.CookTimeButtonVbox.GetChild(cState.ActiveButtonIndex - 1);
-                currentlySelectedTimeButton.Pressed = true;
-            }
+    public override void Update()
+    {
+        base.Update();
 
-            //Set the "micowave light" ui color to indicate if the microwave is busy or not
-            if (cState.IsMicrowaveBusy && cState.ContainedSolids.Length > 0)
-            {
-                _menu.IngredientsPanel.PanelOverride = new StyleBoxFlat { BackgroundColor = Color.FromHex("#947300") };
-            }
-            else
-            {
-                _menu.IngredientsPanel.PanelOverride = new StyleBoxFlat { BackgroundColor = Color.FromHex("#1B1B1E") };
-            }
-        }
+        if (_menu is null || !EntMan.TryGetComponent<MicrowaveComponent>(Owner, out var comp))
+            return;
 
-        private void RefreshContentsDisplay(EntityUid[] containedSolids)
+        RefreshContentsDisplay();
+        UpdateActiveDisplay(comp);
+
+        // Update the currently-selected cook time label and button
+        var buttonIndex = comp.CurrentCookTimeButtonIndex;
+        if (_menu.TryGetCookTimeButton(buttonIndex, out var button))
+            button.Pressed = true;
+
+        var timeLabel = buttonIndex == 0
+            ? Loc.GetString("microwave-menu-instant-button")
+            : comp.CurrentCookTimerTime.ToString();
+
+        _menu.CookTimeInfoLabel.Text = Loc.GetString("microwave-bound-user-interface-cook-time-label",
+            ("time", timeLabel));
+    }
+
+    /// <summary>
+    /// Update the state of various controls in this menu based on the active / empty status of the microwave.
+    /// </summary>
+    private void UpdateActiveDisplay(MicrowaveComponent? comp)
+    {
+        if (_menu is null)
+            return;
+
+        // Disable various UI controls if the microwave is active or empty
+        var isActive = EntMan.TryGetComponent<ActiveMicrowaveComponent>(Owner, out var activeComp);
+        var isEmpty = !_microwave.HasContents((Owner, comp));
+        _menu.IsBusy = isActive;
+        _menu.ToggleBusyDisableOverlayPanel(isActive);
+        _menu.StartButton.Disabled = isActive || isEmpty;
+        _menu.EjectButton.Disabled = isActive || isEmpty;
+
+        if (activeComp != null)
+            _menu.CurrentCooktimeEnd = activeComp.CookTimeEnd;
+
+        // Set the "microwave light" panel color
+        _menu.SetIngredientPanelLight(isActive && !isEmpty);
+    }
+
+    /// <summary>
+    /// Update the panel containing all of the microwave's contents.
+    /// </summary>
+    private void RefreshContentsDisplay()
+    {
+        if (_menu == null)
+            return;
+
+        _solids.Clear();
+        _menu.IngredientsList.Clear();
+        foreach (var entity in _microwave.GetMicrowaveContents(Owner))
         {
-            _reagents.Clear();
+            if (EntMan.Deleted(entity))
+                continue;
 
-            if (_menu == null) return;
-
-            _solids.Clear();
-            _menu.IngredientsList.Clear();
-            foreach (var entity in containedSolids)
-            {
-                if (EntMan.Deleted(entity))
-                {
-                    return;
-                }
-
-                // TODO just use sprite view
-
-                Texture? texture;
-                if (EntMan.TryGetComponent<IconComponent>(entity, out var iconComponent))
-                {
-                    texture = EntMan.System<SpriteSystem>().GetIcon(iconComponent);
-                }
-                else if (EntMan.TryGetComponent<SpriteComponent>(entity, out var spriteComponent))
-                {
-                    texture = spriteComponent.Icon?.Default;
-                }
-                else
-                {
-                    continue;
-                }
-
-                var solidItem = _menu.IngredientsList.AddItem(EntMan.GetComponent<MetaDataComponent>(entity).EntityName, texture);
-                var solidIndex = _menu.IngredientsList.IndexOf(solidItem);
-                _solids.Add(solidIndex, entity);
-            }
+            // TODO just use sprite view
+            var itemIcon = GetEntityIcon(entity);
+            var itemName = EntMan.GetComponent<MetaDataComponent>(entity).EntityName;
+            var solidItem = _menu.IngredientsList.AddItem(itemName, itemIcon);
+            var solidIndex = _menu.IngredientsList.IndexOf(solidItem);
+            _solids.Add(solidIndex, entity);
         }
     }
+
+    /// <summary>
+    /// Get the texture associated with an ingredient.
+    /// </summary>
+    /// <param name="uid">The ingredient entity.</param>
+    private Texture? GetEntityIcon(EntityUid uid)
+    {
+        if (EntMan.TryGetComponent<IconComponent>(uid, out var icon))
+            return _sprite.GetIcon(icon);
+
+        if (EntMan.TryGetComponent<SpriteComponent>(uid, out var sprite))
+            return sprite.Icon?.Default;
+
+        return null;
+    }
 }
diff --git a/Content.Client/Kitchen/UI/MicrowaveCookTimeButton.xaml b/Content.Client/Kitchen/UI/MicrowaveCookTimeButton.xaml
new file mode 100644
index 0000000000..479ca641a2
--- /dev/null
+++ b/Content.Client/Kitchen/UI/MicrowaveCookTimeButton.xaml
@@ -0,0 +1,9 @@
+<Button xmlns="https://spacestation14.io"
+    xmlns:system="clr-namespace:System;assembly=System.Runtime"
+    TextAlign="Center"
+    ToggleMode="True"
+    HorizontalExpand="True">
+    <Button.StyleClasses>
+        <system:String>OpenBoth</system:String>
+    </Button.StyleClasses>
+</Button>
diff --git a/Content.Client/Kitchen/UI/MicrowaveCookTimeButton.xaml.cs b/Content.Client/Kitchen/UI/MicrowaveCookTimeButton.xaml.cs
new file mode 100644
index 0000000000..f6152d5de3
--- /dev/null
+++ b/Content.Client/Kitchen/UI/MicrowaveCookTimeButton.xaml.cs
@@ -0,0 +1,39 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.Kitchen.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class MicrowaveCookTimeButton : Button
+{
+    public event Action<string, uint>? OnCookTimeSelected;
+    private uint _cookTime = 0;
+
+    public uint CookTime
+    {
+        get => _cookTime;
+        set
+        {
+            _cookTime = value;
+            UpdateLabel();
+        }
+    }
+
+    public MicrowaveCookTimeButton()
+    {
+        RobustXamlLoader.Load(this);
+        UpdateLabel();
+
+        OnPressed += _ => OnCookTimeSelected?.Invoke(Text ?? string.Empty, _cookTime);
+    }
+
+    private void UpdateLabel()
+    {
+        var labelText = _cookTime == 0
+            ? Loc.GetString("microwave-menu-instant-button")
+            : _cookTime.ToString();
+
+        Text = labelText;
+    }
+}
diff --git a/Content.Client/Kitchen/UI/MicrowaveMenu.xaml b/Content.Client/Kitchen/UI/MicrowaveMenu.xaml
index a95d51af74..e60fbe8741 100644
--- a/Content.Client/Kitchen/UI/MicrowaveMenu.xaml
+++ b/Content.Client/Kitchen/UI/MicrowaveMenu.xaml
@@ -2,6 +2,7 @@
     xmlns="https://spacestation14.io"
     xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
     xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+    xmlns:kitchen="clr-namespace:Content.Client.Kitchen.UI"
     Title="{Loc 'microwave-menu-title'}"
     MinWidth="512"
     MinSize="512 256">
@@ -49,15 +50,11 @@
                                 Align="Center"
                                 Modulate="#FFFFFF"
                                 VAlign="Center" />
-                            <BoxContainer  Orientation="Vertical">
-                                <Button
+                            <BoxContainer Orientation="Vertical" SeparationOverride="1">
+                                <kitchen:MicrowaveCookTimeButton
                                     Name="InstantCookButton"
-                                    Access="Public"
-                                    Text="{Loc 'microwave-menu-instant-button'}"
-                                    StyleClasses="OpenLeft"
-                                    ToggleMode="True"
-                                    Margin="0 0 2 0"
-                                    TextAlign="Center" />
+                                    CookTime="0"
+                                    StyleClasses="OpenBoth"/>
                                 <GridContainer
                                     Name="CookTimeButtonVbox"
                                     HSeparationOverride="1"
@@ -71,6 +68,7 @@
                                 <BoxContainer
                                     Orientation="Vertical"
                                     Align="Center"
+                                    SeparationOverride="1"
                                     SizeFlagsStretchRatio="3">
                                     <Control MinSize="0 15" />
                                     <Button
diff --git a/Content.Client/Kitchen/UI/MicrowaveMenu.xaml.cs b/Content.Client/Kitchen/UI/MicrowaveMenu.xaml.cs
index bcb2332e8f..19d802f8b2 100644
--- a/Content.Client/Kitchen/UI/MicrowaveMenu.xaml.cs
+++ b/Content.Client/Kitchen/UI/MicrowaveMenu.xaml.cs
@@ -1,83 +1,118 @@
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using FancyWindow = Content.Client.UserInterface.Controls.FancyWindow;
+using System.Diagnostics.CodeAnalysis;
+using Robust.Client.Graphics;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Timing;
 
-namespace Content.Client.Kitchen.UI
+namespace Content.Client.Kitchen.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class MicrowaveMenu : FancyWindow
 {
-    [GenerateTypedNameReferences]
-    public sealed partial class MicrowaveMenu : FancyWindow
+    [Dependency] private IGameTiming _timing = default!;
+
+    public event Action<string, int, uint>? OnCookTimeSelected;
+
+    public ButtonGroup CookTimeButtonGroup { get; }
+    public bool IsBusy;
+    public TimeSpan CurrentCooktimeEnd;
+
+    private readonly StyleBoxFlat _ingredientsStylebox = new();
+
+    public MicrowaveMenu()
     {
-        [Dependency] private IGameTiming _timing = default!;
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
 
-        public event Action<BaseButton.ButtonEventArgs, int>? OnCookTimeSelected;
+        IngredientsPanel.PanelOverride = _ingredientsStylebox;
 
-        public ButtonGroup CookTimeButtonGroup { get; }
+        CookTimeButtonGroup = new ButtonGroup();
+        InstantCookButton.Group = CookTimeButtonGroup;
+        InstantCookButton.OnCookTimeSelected += (name, cookTime) => OnCookTimeButtonPressed(name, 0, cookTime);
 
-        public bool IsBusy;
-        public TimeSpan CurrentCooktimeEnd;
-
-        public MicrowaveMenu()
+        for (var i = 1; i <= 6; i++)
         {
-            RobustXamlLoader.Load(this);
-            IoCManager.InjectDependencies(this);
-            CookTimeButtonGroup = new ButtonGroup();
-            InstantCookButton.Group = CookTimeButtonGroup;
-            InstantCookButton.OnPressed += args =>
+            var cookTime = i * 5;
+            var newButton = new MicrowaveCookTimeButton
             {
-                OnCookTimeSelected?.Invoke(args, 0);
+                CookTime = (uint)cookTime,
+                Group = CookTimeButtonGroup
             };
 
-            for (var i = 1; i <= 6; i++)
-            {
-                var newButton = new MicrowaveCookTimeButton
-                {
-                    Text = (i * 5).ToString(),
-                    TextAlign = Label.AlignMode.Center,
-                    ToggleMode = true,
-                    CookTime = (uint) (i * 5),
-                    Group = CookTimeButtonGroup,
-                    HorizontalExpand = true,
-                };
-                if (i == 4)
-                {
-                    newButton.StyleClasses.Add("OpenRight");
-                }
-                else
-                {
-                    newButton.StyleClasses.Add("OpenBoth");
-                }
-                CookTimeButtonVbox.AddChild(newButton);
-                newButton.OnPressed += args =>
-                {
-                    OnCookTimeSelected?.Invoke(args, i);
-                };
-            }
-        }
-
-        public void ToggleBusyDisableOverlayPanel(bool shouldDisable)
-        {
-            DisableCookingPanelOverlay.Visible = shouldDisable;
-        }
-
-        protected override void FrameUpdate(FrameEventArgs args)
-        {
-            base.FrameUpdate(args);
-
-            if (!IsBusy)
-                return;
-
-            if (CurrentCooktimeEnd > _timing.CurTime)
-            {
-                CookTimeInfoLabel.Text = Loc.GetString("microwave-bound-user-interface-cook-time-label",
-                ("time", CurrentCooktimeEnd.Subtract(_timing.CurTime).Seconds));
-            }
-        }
-
-        public sealed class MicrowaveCookTimeButton : Button
-        {
-            public uint CookTime;
+            newButton.OnCookTimeSelected += (name, cookTime) => OnCookTimeButtonPressed(name, i, cookTime);
+            CookTimeButtonVbox.AddChild(newButton);
         }
     }
+
+    private void OnCookTimeButtonPressed(string name, int index, uint cookTime)
+    {
+        OnCookTimeSelected?.Invoke(name, index, cookTime);
+    }
+
+    /// <summary>
+    /// Set the visibility of the "busy overlay panel" over the microwave's ingredients,
+    /// indicating to the player that the ingredients list cannot be interacted with
+    /// (namely while the microwave is active.)
+    /// </summary>
+    /// <param name="shouldDisable">Whether or not this microwave is "busy".</param>
+    public void ToggleBusyDisableOverlayPanel(bool shouldDisable)
+    {
+        DisableCookingPanelOverlay.Visible = shouldDisable;
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        base.FrameUpdate(args);
+
+        if (!IsBusy)
+            return;
+
+        var remaining = CurrentCooktimeEnd - _timing.CurTime;
+        if (remaining > TimeSpan.Zero)
+        {
+            CookTimeInfoLabel.Text = Loc.GetString("microwave-bound-user-interface-cook-time-label",
+                ("time", Math.Ceiling(remaining.TotalSeconds)));
+        }
+    }
+
+    /// <summary>
+    /// Set the "color light" state of the ingredient panel's ingredient box.
+    /// </summary>
+    /// <param name="value">Wheether or not the panel is "lit" (yellow) or "unlit" (gray).</param>
+    public void SetIngredientPanelLight(bool value)
+    {
+        var panelColor = value
+            ? Color.DarkGoldenrod
+            : Color.FromHex("#1B1B1E");
+
+        _ingredientsStylebox.BackgroundColor = panelColor;
+    }
+
+    /// <summary>
+    /// Attempt to get the cook time button at the given index.
+    /// </summary>
+    /// <param name="index">The index to select.</param>
+    /// <param name="button">The cook time button, if found.</param>
+    /// <returns>Whether or not this operation was successful.</returns>
+    public bool TryGetCookTimeButton(int index,
+        [NotNullWhen(true)] out Button? button)
+    {
+        button = null;
+
+        if (index == 0)
+            button = InstantCookButton;
+        else
+        {
+            if (index <= CookTimeButtonVbox.ChildCount)
+            {
+                var control = CookTimeButtonVbox.GetChild(index - 1);
+                if (control is Button timeButton)
+                    button = timeButton;
+            }
+        }
+
+        return button != null;
+    }
 }
diff --git a/Content.IntegrationTests/Tests/Kitchen/MicrowaveRecipeTest.cs b/Content.IntegrationTests/Tests/Kitchen/MicrowaveRecipeTest.cs
new file mode 100644
index 0000000000..212aa11be3
--- /dev/null
+++ b/Content.IntegrationTests/Tests/Kitchen/MicrowaveRecipeTest.cs
@@ -0,0 +1,86 @@
+using Content.IntegrationTests.Fixtures;
+using Content.IntegrationTests.Fixtures.Attributes;
+using Content.IntegrationTests.Utility;
+using Content.Server.Kitchen.EntitySystems;
+using Content.Shared.Kitchen;
+using Content.Shared.Kitchen.Components;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Kitchen;
+
+/// <summary>
+/// Integration tests related to microwaves and microwave recipes.
+/// </summary>
+public sealed class MicrowaveRecipeTest : GameTest
+{
+    [SidedDependency(Side.Server)] private readonly ServerMicrowaveSystem _microwave = null!;
+
+    private static readonly string[] Recipes = GameDataScrounger.PrototypesOfKind<MicrowaveMealRecipePrototype>();
+    private static readonly EntProtoId MicrowavePrototype = "KitchenMicrowave";
+    private const uint MaxSeconds = 30;
+
+    [Test]
+    [TestOf(typeof(ServerMicrowaveSystem))]
+    [TestCaseSource(nameof(Recipes))]
+    [Description("Checks whether a microwave recipe's ingredients will create that recipe in the microwave.")]
+    public async Task AllRecipeIngredientsMakeRecipe(string protoKey)
+    {
+        var server = Pair.Server;
+
+        // Spawn the microwave we will use for our recipes.
+        var microwave = await Spawn(MicrowavePrototype);
+        var microwaveString = SEntMan.ToPrettyString(microwave);
+
+        await server.WaitAssertion(() =>
+        {
+            Assert.That(SEntMan.HasComponent<MicrowaveComponent>(microwave),
+                $"Microwave entity {microwaveString} lacks a {nameof(MicrowaveComponent)}!");
+
+            // Get the parameters we need to make this recipe.
+            var proto = SProtoMan.Index<MicrowaveMealRecipePrototype>(protoKey);
+            var maxPortions = MaxSeconds / proto.Time;
+
+            // Ensure this recipe is provided to the microwave if this is a secret recipe.
+            if (proto.SecretRecipe)
+            {
+                var recipeProvider = SEntMan.EnsureComponent<FoodRecipeProviderComponent>(microwave);
+                recipeProvider.ProvidedRecipes.Add(protoKey);
+            }
+
+            // First, test that a single portion works.
+            ValidateRecipePortions(proto, 1, microwave);
+
+            // Then, test that making multiple portions of the same recipe works.
+            if (maxPortions > 1)
+                ValidateRecipePortions(proto, maxPortions, microwave);
+        });
+    }
+
+    private void ValidateRecipePortions(MicrowaveMealRecipePrototype prototype, uint portions, EntityUid microwave)
+    {
+        var ingredients = prototype.Ingredients * portions;
+        var cookTime = prototype.Time * portions;
+        var portionedRecipe = _microwave.GetRecipe(microwave, ingredients, cookTime);
+        var microwaveString = SEntMan.ToPrettyString(microwave);
+        var recipeDebugString = $"Ingredients for {nameof(MicrowaveMealRecipePrototype)} {prototype.ID}";
+
+        using (Assert.EnterMultipleScope())
+        {
+            // Tried to get a recipe for these ingredients, but no valid recipe was found.
+            Assert.That(portionedRecipe, Is.Not.Null,
+                $"{recipeDebugString} did not resolve to a recipe in {microwaveString} in {portions} portions!");
+
+            var recipe = portionedRecipe.Value.Recipe;
+            var count = portionedRecipe.Value.Count;
+
+            // Resulted in a different recipe instead.
+            Assert.That(recipe, Is.EqualTo(prototype.ID),
+                $"{recipeDebugString} resulted in an incorrect recipe for {microwaveString} in {portions} portions!");
+
+            // Recipe portion count does not match the amount we're trying to make.
+            Assert.That(count, Is.EqualTo(portions),
+                $"{recipeDebugString} resulted in {count} recipe portions for {microwaveString}! Expected: {portions}");
+        }
+    }
+}
diff --git a/Content.IntegrationTests/Tests/WizdenContentFreeze/WizdenContentFreeze.cs b/Content.IntegrationTests/Tests/WizdenContentFreeze/WizdenContentFreeze.cs
index 801c6c49b6..c4ac6d7990 100644
--- a/Content.IntegrationTests/Tests/WizdenContentFreeze/WizdenContentFreeze.cs
+++ b/Content.IntegrationTests/Tests/WizdenContentFreeze/WizdenContentFreeze.cs
@@ -24,7 +24,7 @@ public sealed class WizdenContentFreeze : GameTest
 
         var protoMan = server.ProtoMan;
 
-        var recipesCount = protoMan.Count<FoodRecipePrototype>();
+        var recipesCount = protoMan.Count<MicrowaveMealRecipePrototype>();
         var recipesLimit = 218;
 
         if (recipesCount > recipesLimit)
diff --git a/Content.Server/Access/Systems/IdCardSystem.cs b/Content.Server/Access/Systems/IdCardSystem.cs
index 1c3112a628..fb96fd4aaa 100644
--- a/Content.Server/Access/Systems/IdCardSystem.cs
+++ b/Content.Server/Access/Systems/IdCardSystem.cs
@@ -1,7 +1,6 @@
 using System.Linq;
 using Content.Server.Administration.Logs;
 using Content.Server.Chat.Systems;
-using Content.Server.Kitchen.Components;
 using Content.Server.Popups;
 using Content.Shared.Access;
 using Content.Shared.Access.Components;
@@ -9,9 +8,10 @@ using Content.Shared.Access.Systems;
 using Content.Shared.Chat;
 using Content.Shared.Database;
 using Content.Shared.Kitchen;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Kitchen.EntitySystems;
 using Content.Shared.Popups;
 using Robust.Shared.Random;
-using Content.Server.Kitchen.EntitySystems;
 
 namespace Content.Server.Access.Systems;
 
diff --git a/Content.Server/Kitchen/Components/ActiveMicrowaveComponent.cs b/Content.Server/Kitchen/Components/ActiveMicrowaveComponent.cs
deleted file mode 100644
index 1e32e039db..0000000000
--- a/Content.Server/Kitchen/Components/ActiveMicrowaveComponent.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using Content.Shared.Kitchen;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
-
-namespace Content.Server.Kitchen.Components;
-
-/// <summary>
-/// Attached to a microwave that is currently in the process of cooking
-/// </summary>
-[RegisterComponent, AutoGenerateComponentPause]
-public sealed partial class ActiveMicrowaveComponent : Component
-{
-    [ViewVariables(VVAccess.ReadWrite)]
-    public float CookTimeRemaining;
-
-    [ViewVariables(VVAccess.ReadWrite)]
-    public float TotalTime;
-
-    [ViewVariables(VVAccess.ReadWrite)]
-    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
-    [AutoPausedField]
-    public TimeSpan MalfunctionTime = TimeSpan.Zero;
-
-    [ViewVariables]
-    public (FoodRecipePrototype?, int) PortionedRecipe;
-}
diff --git a/Content.Server/Kitchen/Components/MicrowaveComponent.cs b/Content.Server/Kitchen/Components/MicrowaveComponent.cs
deleted file mode 100644
index df8218c7a8..0000000000
--- a/Content.Server/Kitchen/Components/MicrowaveComponent.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-using Content.Shared.Construction.Prototypes;
-using Content.Shared.DeviceLinking;
-using Content.Shared.Item;
-using Robust.Shared.Audio;
-using Robust.Shared.Containers;
-using Robust.Shared.Prototypes;
-
-namespace Content.Server.Kitchen.Components
-{
-    [RegisterComponent]
-    public sealed partial class MicrowaveComponent : Component
-    {
-        [DataField]
-        public float CookTimeMultiplier = 1;
-
-        [DataField]
-        public float BaseHeatMultiplier = 100;
-
-        [DataField]
-        public float ObjectHeatMultiplier = 100;
-
-        [DataField("failureResult")]
-        public EntProtoId BadRecipeEntityId = "FoodBadRecipe";
-
-        #region  audio
-        [DataField("beginCookingSound")]
-        public SoundSpecifier StartCookingSound = new SoundPathSpecifier("/Audio/Machines/microwave_start_beep.ogg");
-
-        [DataField]
-        public SoundSpecifier FoodDoneSound = new SoundPathSpecifier("/Audio/Machines/microwave_done_beep.ogg");
-
-        [DataField]
-        public SoundSpecifier ClickSound = new SoundPathSpecifier("/Audio/Machines/machine_switch.ogg");
-
-        [DataField("ItemBreakSound")]
-        public SoundSpecifier ItemBreakSound = new SoundPathSpecifier("/Audio/Effects/clang.ogg");
-
-        public EntityUid? PlayingStream;
-
-        [DataField]
-        public SoundSpecifier LoopingSound = new SoundPathSpecifier("/Audio/Machines/microwave_loop.ogg");
-        #endregion
-
-        [DataField]
-        public bool Broken;
-
-        [DataField]
-        public ProtoId<SinkPortPrototype> OnPort = "On";
-
-        /// <summary>
-        /// This is a fixed offset of 5.
-        /// The cook times for all recipes should be divisible by 5,with a minimum of 1 second.
-        /// For right now, I don't think any recipe cook time should be greater than 60 seconds.
-        /// </summary>
-        [DataField]
-        public uint CurrentCookTimerTime = 0;
-
-        /// <summary>
-        /// Tracks the elapsed time of the current cook timer.
-        /// </summary>
-        [DataField]
-        public TimeSpan CurrentCookTimeEnd = TimeSpan.Zero;
-
-        /// <summary>
-        /// The maximum number of seconds a microwave can be set to.
-        /// This is currently only used for validation and the client does not check this.
-        /// </summary>
-        [DataField]
-        public uint MaxCookTime = 30;
-
-        /// <summary>
-        ///     The max temperature that this microwave can heat objects to.
-        /// </summary>
-        [DataField]
-        public float TemperatureUpperThreshold = 373.15f;
-
-        public int CurrentCookTimeButtonIndex;
-
-        public Container Storage = default!;
-
-        [DataField]
-        public string ContainerId = "microwave_entity_container";
-
-        [DataField]
-        public int Capacity = 10;
-
-        [DataField]
-        public ProtoId<ItemSizePrototype> MaxItemSize = "Normal";
-
-        /// <summary>
-        /// How frequently the microwave can malfunction.
-        /// </summary>
-        [DataField]
-        public float MalfunctionInterval = 1.0f;
-
-        /// <summary>
-        /// Chance of an explosion occurring when we microwave a metallic object
-        /// </summary>
-        [DataField]
-        public float ExplosionChance = .1f;
-
-        /// <summary>
-        /// Chance of lightning occurring when we microwave a metallic object
-        [DataField]
-        public float LightningChance = .75f;
-
-        /// <summary>
-        /// If this microwave can give ids accesses without exploding
-        /// </summary>
-        [DataField]
-        public bool CanMicrowaveIdsSafely = true;
-    }
-}
diff --git a/Content.Server/Kitchen/EntitySystems/MicrowaveSystem.cs b/Content.Server/Kitchen/EntitySystems/MicrowaveSystem.cs
deleted file mode 100644
index ab9cc981d9..0000000000
--- a/Content.Server/Kitchen/EntitySystems/MicrowaveSystem.cs
+++ /dev/null
@@ -1,761 +0,0 @@
-using System.Linq;
-using Content.Server.Administration.Logs;
-using Content.Server.Construction;
-using Content.Server.Construction.Components;
-using Content.Server.DeviceLinking.Systems;
-using Content.Server.Explosion.EntitySystems;
-using Content.Server.Hands.Systems;
-using Content.Server.Kitchen.Components;
-using Content.Server.Lightning;
-using Content.Server.Power.Components;
-using Content.Server.Power.EntitySystems;
-using Content.Server.Temperature.Systems;
-using Content.Shared.Chemistry.EntitySystems;
-using Content.Shared.Chemistry.Reaction;
-using Content.Shared.Chemistry.Reagent;
-using Content.Shared.Construction.EntitySystems;
-using Content.Shared.Damage.Components;
-using Content.Shared.Database;
-using Content.Shared.Destructible;
-using Content.Shared.DeviceLinking.Events;
-using Content.Shared.FixedPoint;
-using Content.Shared.IdentityManagement;
-using Content.Shared.Interaction;
-using Content.Shared.Interaction.Events;
-using Content.Shared.Item;
-using Content.Shared.Kitchen;
-using Content.Shared.Kitchen.Components;
-using Content.Shared.Popups;
-using Content.Shared.Power;
-using Content.Shared.Power.EntitySystems;
-using Content.Shared.Stacks;
-using Content.Shared.Suicide;
-using Content.Shared.Tag;
-using Robust.Server.GameObjects;
-using Robust.Shared.Audio;
-using Robust.Shared.Audio.Systems;
-using Robust.Shared.Containers;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Random;
-using Robust.Shared.Timing;
-
-namespace Content.Server.Kitchen.EntitySystems
-{
-    public sealed partial class MicrowaveSystem : EntitySystem
-    {
-        [Dependency] private DeviceLinkSystem _deviceLink = default!;
-        [Dependency] private SharedPopupSystem _popupSystem = default!;
-        [Dependency] private PowerReceiverSystem _power = default!;
-        [Dependency] private RecipeManager _recipeManager = default!;
-        [Dependency] private SharedAppearanceSystem _appearance = default!;
-        [Dependency] private SharedAudioSystem _audio = default!;
-        [Dependency] private LightningSystem _lightning = default!;
-        [Dependency] private IRobustRandom _random = default!;
-        [Dependency] private IGameTiming _gameTiming = default!;
-        [Dependency] private ExplosionSystem _explosion = default!;
-        [Dependency] private SharedContainerSystem _container = default!;
-        [Dependency] private SharedSolutionContainerSystem _solutionContainer = default!;
-        [Dependency] private TagSystem _tag = default!;
-        [Dependency] private TemperatureSystem _temperature = default!;
-        [Dependency] private UserInterfaceSystem _userInterface = default!;
-        [Dependency] private HandsSystem _handsSystem = default!;
-        [Dependency] private SharedItemSystem _item = default!;
-        [Dependency] private SharedStackSystem _stack = default!;
-        [Dependency] private IAdminLogManager _adminLogger = default!;
-        [Dependency] private SharedSuicideSystem _suicide = default!;
-        [Dependency] private SharedPowerStateSystem _powerState = default!;
-
-        private static readonly EntProtoId MalfunctionSpark = "Spark";
-
-        private static readonly ProtoId<TagPrototype> MetalTag = "Metal";
-        private static readonly ProtoId<TagPrototype> PlasticTag = "Plastic";
-
-        public override void Initialize()
-        {
-            base.Initialize();
-
-            SubscribeLocalEvent<MicrowaveComponent, ComponentInit>(OnInit);
-            SubscribeLocalEvent<MicrowaveComponent, MapInitEvent>(OnMapInit);
-            SubscribeLocalEvent<MicrowaveComponent, SolutionChangedEvent>(OnSolutionChange);
-            SubscribeLocalEvent<MicrowaveComponent, EntInsertedIntoContainerMessage>(OnContentUpdate);
-            SubscribeLocalEvent<MicrowaveComponent, EntRemovedFromContainerMessage>(OnContentUpdate);
-            SubscribeLocalEvent<MicrowaveComponent, InteractUsingEvent>(OnInteractUsing, after: new[] { typeof(AnchorableSystem) });
-            SubscribeLocalEvent<MicrowaveComponent, ContainerIsInsertingAttemptEvent>(OnInsertAttempt);
-            SubscribeLocalEvent<MicrowaveComponent, BreakageEventArgs>(OnBreak);
-            SubscribeLocalEvent<MicrowaveComponent, PowerChangedEvent>(OnPowerChanged);
-            SubscribeLocalEvent<MicrowaveComponent, AnchorStateChangedEvent>(OnAnchorChanged);
-            SubscribeLocalEvent<MicrowaveComponent, SuicideByEnvironmentEvent>(OnSuicideByEnvironment);
-
-            SubscribeLocalEvent<MicrowaveComponent, SignalReceivedEvent>(OnSignalReceived);
-
-            SubscribeLocalEvent<MicrowaveComponent, MicrowaveStartCookMessage>((u, c, m) => Wzhzhzh(u, c, m.Actor));
-            SubscribeLocalEvent<MicrowaveComponent, MicrowaveEjectMessage>(OnEjectMessage);
-            SubscribeLocalEvent<MicrowaveComponent, MicrowaveEjectSolidIndexedMessage>(OnEjectIndex);
-            SubscribeLocalEvent<MicrowaveComponent, MicrowaveSelectCookTimeMessage>(OnSelectTime);
-
-            SubscribeLocalEvent<ActiveMicrowaveComponent, ComponentStartup>(OnCookStart);
-            SubscribeLocalEvent<ActiveMicrowaveComponent, ComponentShutdown>(OnCookStop);
-            SubscribeLocalEvent<ActiveMicrowaveComponent, EntInsertedIntoContainerMessage>(OnActiveMicrowaveInsert);
-            SubscribeLocalEvent<ActiveMicrowaveComponent, EntRemovedFromContainerMessage>(OnActiveMicrowaveRemove);
-
-            SubscribeLocalEvent<ActivelyMicrowavedComponent, OnConstructionTemperatureEvent>(OnConstructionTemp);
-            SubscribeLocalEvent<ActivelyMicrowavedComponent, SolutionRelayEvent<ReactionAttemptEvent>>(OnReactionAttemptRelay);
-            SubscribeLocalEvent<ActivelyMicrowavedComponent, ReactionAttemptEvent>(OnReactionAttempt);
-
-            SubscribeLocalEvent<FoodRecipeProviderComponent, GetSecretRecipesEvent>(OnGetSecretRecipes);
-        }
-
-        private void OnCookStart(Entity<ActiveMicrowaveComponent> ent, ref ComponentStartup args)
-        {
-            if (!TryComp<MicrowaveComponent>(ent, out var microwaveComponent))
-                return;
-            SetAppearance(ent.Owner, MicrowaveVisualState.Cooking, microwaveComponent);
-
-            var audioParams = microwaveComponent.LoopingSound?.Params ?? AudioParams.Default;
-            audioParams = audioParams.WithLoop(true).WithMaxDistance(5);
-            microwaveComponent.PlayingStream = _audio.PlayPvs(microwaveComponent.LoopingSound, ent, audioParams)?.Entity;
-            _powerState.SetWorkingState(ent.Owner, true);
-        }
-
-        private void OnCookStop(Entity<ActiveMicrowaveComponent> ent, ref ComponentShutdown args)
-        {
-            if (!TryComp<MicrowaveComponent>(ent, out var microwaveComponent))
-                return;
-
-            SetAppearance(ent.Owner, MicrowaveVisualState.Idle, microwaveComponent);
-            microwaveComponent.PlayingStream = _audio.Stop(microwaveComponent.PlayingStream);
-            _powerState.SetWorkingState(ent.Owner, false);
-        }
-
-        private void OnActiveMicrowaveInsert(Entity<ActiveMicrowaveComponent> ent, ref EntInsertedIntoContainerMessage args)
-        {
-            var microwavedComp = AddComp<ActivelyMicrowavedComponent>(args.Entity);
-            microwavedComp.Microwave = ent.Owner;
-        }
-
-        private void OnActiveMicrowaveRemove(Entity<ActiveMicrowaveComponent> ent, ref EntRemovedFromContainerMessage args)
-        {
-            RemCompDeferred<ActivelyMicrowavedComponent>(args.Entity);
-        }
-
-        // Stop items from transforming through constructiongraphs while being microwaved.
-        // They might be reserved for a microwave recipe.
-        private void OnConstructionTemp(Entity<ActivelyMicrowavedComponent> ent, ref OnConstructionTemperatureEvent args)
-        {
-            args.Result = HandleResult.False;
-        }
-
-        private void OnReactionAttemptRelay(Entity<ActivelyMicrowavedComponent> ent, ref SolutionRelayEvent<ReactionAttemptEvent> args)
-        {
-            OnReactionAttempt(ent, ref args.Event);
-        }
-
-        // Stop reagents from reacting if they are currently reserved for a microwave recipe.
-        // For example Egg would cook into EggCooked, causing it to not being removed once we are done microwaving.
-        private void OnReactionAttempt(Entity<ActivelyMicrowavedComponent> ent, ref ReactionAttemptEvent args)
-        {
-            if (!TryComp<ActiveMicrowaveComponent>(ent.Comp.Microwave, out var activeMicrowaveComp))
-                return;
-
-            if (activeMicrowaveComp.PortionedRecipe.Item1 == null) // no recipe selected
-                return;
-
-            var recipeReagents = activeMicrowaveComp.PortionedRecipe.Item1.IngredientsReagents.Keys;
-
-            foreach (var reagent in recipeReagents)
-            {
-                if (args.Reaction.Reactants.ContainsKey(reagent))
-                {
-                    args.Cancelled = true;
-                    return;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Adds temperature to every item in the microwave,
-        ///     based on the time it took to microwave.
-        /// </summary>
-        /// <param name="component">The microwave that is heating up.</param>
-        /// <param name="time">The time on the microwave, in seconds.</param>
-        private void AddTemperature(MicrowaveComponent component, float time)
-        {
-            var heatToAdd = time * component.BaseHeatMultiplier;
-            foreach (var entity in component.Storage.ContainedEntities)
-            {
-                _temperature.ChangeHeat(entity, heatToAdd * component.ObjectHeatMultiplier, false);
-
-                foreach (var (_, soln) in _solutionContainer.EnumerateSolutions(entity))
-                {
-                    var solution = soln.Comp.Solution;
-                    if (solution.Temperature > component.TemperatureUpperThreshold)
-                        continue;
-
-                    _solutionContainer.AddThermalEnergy(soln, heatToAdd);
-                }
-            }
-        }
-
-        private void SubtractContents(MicrowaveComponent component, FoodRecipePrototype recipe)
-        {
-            // TODO Turn recipe.IngredientsReagents into a ReagentQuantity[]
-
-            var totalReagentsToRemove = new Dictionary<ProtoId<ReagentPrototype>, FixedPoint2>(recipe.IngredientsReagents);
-
-            // this is spaghetti ngl
-            foreach (var item in component.Storage.ContainedEntities)
-            {
-                // use the same reagents as when we selected the recipe
-                if (!_solutionContainer.TryGetDrainableSolution(item, out var solutionEntity, out var solution))
-                    continue;
-
-                foreach (var (reagent, _) in recipe.IngredientsReagents)
-                {
-                    // removed everything
-                    if (!totalReagentsToRemove.ContainsKey(reagent))
-                        continue;
-
-                    var quant = solution.GetTotalPrototypeQuantity(reagent);
-
-                    if (quant >= totalReagentsToRemove[reagent])
-                    {
-                        quant = totalReagentsToRemove[reagent];
-                        totalReagentsToRemove.Remove(reagent);
-                    }
-                    else
-                    {
-                        totalReagentsToRemove[reagent] -= quant;
-                    }
-
-                    _solutionContainer.RemoveReagent(solutionEntity.Value, reagent, quant);
-                }
-            }
-
-            foreach (var recipeSolid in recipe.IngredientsSolids)
-            {
-                for (var i = 0; i < recipeSolid.Value; i++)
-                {
-                    foreach (var item in component.Storage.ContainedEntities)
-                    {
-                        string? itemID = null;
-
-                        // If an entity has a stack component, use the stacktype instead of prototype id
-                        if (TryComp<StackComponent>(item, out var stackComp))
-                        {
-                            itemID = ProtoMan.Index(stackComp.StackTypeId).Spawn;
-                        }
-                        else
-                        {
-                            var metaData = MetaData(item);
-                            if (metaData.EntityPrototype == null)
-                            {
-                                continue;
-                            }
-                            itemID = metaData.EntityPrototype.ID;
-                        }
-
-                        if (itemID != recipeSolid.Key)
-                        {
-                            continue;
-                        }
-
-                        if (stackComp is not null)
-                        {
-                            if (stackComp.Count == 1)
-                            {
-                                _container.Remove(item, component.Storage);
-                            }
-                            _stack.ReduceCount((item, stackComp), 1);
-                            break;
-                        }
-                        else
-                        {
-                            _container.Remove(item, component.Storage);
-                            Del(item);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        private void OnInit(Entity<MicrowaveComponent> ent, ref ComponentInit args)
-        {
-            // this really does have to be in ComponentInit
-            ent.Comp.Storage = _container.EnsureContainer<Container>(ent, ent.Comp.ContainerId);
-        }
-
-        private void OnMapInit(Entity<MicrowaveComponent> ent, ref MapInitEvent args)
-        {
-            _deviceLink.EnsureSinkPorts(ent, ent.Comp.OnPort);
-        }
-
-        /// <summary>
-        /// Kills the user by microwaving their head
-        /// TODO: Make this not awful, it keeps any items attached to your head still on and you can revive someone and cogni them so you have some dumb headless fuck running around. I've seen it happen.
-        /// </summary>
-        private void OnSuicideByEnvironment(Entity<MicrowaveComponent> ent, ref SuicideByEnvironmentEvent args)
-        {
-            if (args.Handled)
-                return;
-
-            // The act of getting your head microwaved doesn't actually kill you
-            if (!TryComp<DamageableComponent>(args.Victim, out var damageableComponent))
-                return;
-
-            // The application of lethal damage is what kills you...
-            _suicide.ApplyLethalDamage((args.Victim, damageableComponent), "Heat");
-
-            var victim = args.Victim;
-
-            var selfMessage = Loc.GetString("microwave-component-suicide-message");
-            var othersMessage = Loc.GetString("microwave-component-suicide-others-message", ("victim", Identity.Entity(victim, EntityManager)));
-
-            _popupSystem.PopupEntity(selfMessage, othersMessage, victim, victim);
-
-            var audioParams = ent.Comp.ClickSound?.Params ?? AudioParams.Default;
-            audioParams = audioParams.AddVolume(-2);
-            _audio.PlayPvs(ent.Comp.ClickSound, ent.Owner, audioParams);
-            ent.Comp.CurrentCookTimerTime = 10;
-            Wzhzhzh(ent.Owner, ent.Comp, args.Victim);
-            UpdateUserInterfaceState(ent.Owner, ent.Comp);
-            args.Handled = true;
-        }
-
-        private void OnSolutionChange(Entity<MicrowaveComponent> ent, ref SolutionChangedEvent args)
-        {
-            UpdateUserInterfaceState(ent, ent.Comp);
-        }
-
-        private void OnContentUpdate(EntityUid uid, MicrowaveComponent component, ContainerModifiedMessage args) // For some reason ContainerModifiedMessage just can't be used at all with Entity<T>. TODO: replace with Entity<T> syntax once that's possible
-        {
-            if (component.Storage != args.Container)
-                return;
-
-            UpdateUserInterfaceState(uid, component);
-        }
-
-        private void OnInsertAttempt(Entity<MicrowaveComponent> ent, ref ContainerIsInsertingAttemptEvent args)
-        {
-            if (args.Container.ID != ent.Comp.ContainerId)
-                return;
-
-            if (ent.Comp.Broken)
-            {
-                args.Cancel();
-                return;
-            }
-
-            if (TryComp<ItemComponent>(args.EntityUid, out var item))
-            {
-                if (_item.GetSizePrototype(item.Size) > _item.GetSizePrototype(ent.Comp.MaxItemSize))
-                {
-                    args.Cancel();
-                    return;
-                }
-            }
-            else
-            {
-                args.Cancel();
-                return;
-            }
-
-            if (ent.Comp.Storage.Count >= ent.Comp.Capacity)
-                args.Cancel();
-        }
-
-        private void OnInteractUsing(Entity<MicrowaveComponent> ent, ref InteractUsingEvent args)
-        {
-            if (args.Handled)
-                return;
-            if (!(TryComp<ApcPowerReceiverComponent>(ent, out var apc) && apc.Powered))
-            {
-                _popupSystem.PopupEntity(Loc.GetString("microwave-component-interact-using-no-power"), ent, args.User);
-                return;
-            }
-
-            if (ent.Comp.Broken)
-            {
-                _popupSystem.PopupEntity(Loc.GetString("microwave-component-interact-using-broken"), ent, args.User);
-                return;
-            }
-
-            if (TryComp<ItemComponent>(args.Used, out var item))
-            {
-                // check if size of an item you're trying to put in is too big
-                if (_item.GetSizePrototype(item.Size) > _item.GetSizePrototype(ent.Comp.MaxItemSize))
-                {
-                    _popupSystem.PopupEntity(Loc.GetString("microwave-component-interact-item-too-big", ("item", args.Used)), ent, args.User);
-                    return;
-                }
-            }
-            else
-            {
-                // check if thing you're trying to put in isn't an item
-                _popupSystem.PopupEntity(Loc.GetString("microwave-component-interact-using-transfer-fail"), ent, args.User);
-                return;
-            }
-
-            if (ent.Comp.Storage.Count >= ent.Comp.Capacity)
-            {
-                _popupSystem.PopupEntity(Loc.GetString("microwave-component-interact-full"), ent, args.User);
-                return;
-            }
-
-            args.Handled = true;
-            _handsSystem.TryDropIntoContainer(args.User, args.Used, ent.Comp.Storage);
-            UpdateUserInterfaceState(ent, ent.Comp);
-        }
-
-        private void OnBreak(Entity<MicrowaveComponent> ent, ref BreakageEventArgs args)
-        {
-            ent.Comp.Broken = true;
-            SetAppearance(ent, MicrowaveVisualState.Broken, ent.Comp);
-            StopCooking(ent);
-            _container.EmptyContainer(ent.Comp.Storage);
-            UpdateUserInterfaceState(ent, ent.Comp);
-        }
-
-        private void OnPowerChanged(Entity<MicrowaveComponent> ent, ref PowerChangedEvent args)
-        {
-            if (!args.Powered)
-            {
-                SetAppearance(ent, MicrowaveVisualState.Idle, ent.Comp);
-                StopCooking(ent);
-            }
-            UpdateUserInterfaceState(ent, ent.Comp);
-        }
-
-        private void OnAnchorChanged(EntityUid uid, MicrowaveComponent component, ref AnchorStateChangedEvent args)
-        {
-            if (!args.Anchored)
-                _container.EmptyContainer(component.Storage);
-        }
-
-        private void OnSignalReceived(Entity<MicrowaveComponent> ent, ref SignalReceivedEvent args)
-        {
-            if (args.Port != ent.Comp.OnPort)
-                return;
-
-            if (ent.Comp.Broken || !_power.IsPowered(ent))
-                return;
-
-            Wzhzhzh(ent.Owner, ent.Comp, null);
-        }
-
-        public void UpdateUserInterfaceState(EntityUid uid, MicrowaveComponent component)
-        {
-            _userInterface.SetUiState(uid, MicrowaveUiKey.Key, new MicrowaveUpdateUserInterfaceState(
-                GetNetEntityArray(component.Storage.ContainedEntities.ToArray()),
-                HasComp<ActiveMicrowaveComponent>(uid),
-                component.CurrentCookTimeButtonIndex,
-                component.CurrentCookTimerTime,
-                component.CurrentCookTimeEnd
-            ));
-        }
-
-        public void SetAppearance(EntityUid uid, MicrowaveVisualState state, MicrowaveComponent? component = null, AppearanceComponent? appearanceComponent = null)
-        {
-            if (!Resolve(uid, ref component, ref appearanceComponent, false))
-                return;
-            var display = component.Broken ? MicrowaveVisualState.Broken : state;
-            _appearance.SetData(uid, PowerDeviceVisuals.VisualState, display, appearanceComponent);
-        }
-
-        public static bool HasContents(MicrowaveComponent component)
-        {
-            return component.Storage.ContainedEntities.Any();
-        }
-
-        /// <summary>
-        /// Explodes the microwave internally, turning it into a broken state, destroying its board, and spitting out its machine parts
-        /// </summary>
-        /// <param name="ent"></param>
-        public void Explode(Entity<MicrowaveComponent> ent)
-        {
-            ent.Comp.Broken = true; // Make broken so we stop processing stuff
-            _explosion.TriggerExplosive(ent);
-            if (TryComp<MachineComponent>(ent, out var machine))
-            {
-                _container.CleanContainer(machine.BoardContainer);
-                _container.EmptyContainer(machine.PartContainer);
-            }
-
-            _adminLogger.Add(LogType.Action, LogImpact.Medium,
-                $"{ToPrettyString(ent)} exploded from unsafe cooking!");
-        }
-        /// <summary>
-        /// Handles the attempted cooking of unsafe objects
-        /// </summary>
-        /// <remarks>
-        /// Returns false if the microwave didn't explode, true if it exploded.
-        /// </remarks>
-        private void RollMalfunction(Entity<ActiveMicrowaveComponent, MicrowaveComponent> ent)
-        {
-            if (ent.Comp1.MalfunctionTime == TimeSpan.Zero)
-                return;
-
-            if (ent.Comp1.MalfunctionTime > _gameTiming.CurTime)
-                return;
-
-            ent.Comp1.MalfunctionTime = _gameTiming.CurTime + TimeSpan.FromSeconds(ent.Comp2.MalfunctionInterval);
-            if (_random.Prob(ent.Comp2.ExplosionChance))
-            {
-                Explode((ent, ent.Comp2));
-                return;  // microwave is fucked, stop the cooking.
-            }
-
-            if (_random.Prob(ent.Comp2.LightningChance))
-                _lightning.ShootRandomLightnings(ent, 1.0f, 2, MalfunctionSpark, triggerLightningEvents: false);
-        }
-
-        /// <summary>
-        /// Starts Cooking
-        /// </summary>
-        /// <remarks>
-        /// It does not make a "wzhzhzh" sound, it makes a "mmmmmmmm" sound!
-        /// -emo
-        /// </remarks>
-        public void Wzhzhzh(EntityUid uid, MicrowaveComponent component, EntityUid? user)
-        {
-            if (!HasContents(component) || HasComp<ActiveMicrowaveComponent>(uid) || !(TryComp<ApcPowerReceiverComponent>(uid, out var apc) && apc.Powered))
-                return;
-
-            var solidsDict = new Dictionary<string, int>();
-            var reagentDict = new Dictionary<string, FixedPoint2>();
-            var malfunctioning = false;
-            // TODO use lists of Reagent quantities instead of reagent prototype ids.
-            foreach (var item in component.Storage.ContainedEntities.ToArray())
-            {
-                // special behavior when being microwaved ;)
-                var ev = new BeingMicrowavedEvent(uid, user);
-                RaiseLocalEvent(item, ev);
-
-                // TODO MICROWAVE SPARKS & EFFECTS
-                // Various microwaveable entities should probably spawn a spark, play a sound, and generate a pop=up.
-                // This should probably be handled by the microwave system, with fields in BeingMicrowavedEvent.
-
-                if (ev.Handled)
-                {
-                    UpdateUserInterfaceState(uid, component);
-                    return;
-                }
-
-                if (_tag.HasTag(item, MetalTag))
-                {
-                    malfunctioning = true;
-                }
-
-                if (_tag.HasTag(item, PlasticTag))
-                {
-                    var junk = Spawn(component.BadRecipeEntityId, Transform(uid).Coordinates);
-                    _container.Insert(junk, component.Storage);
-                    Del(item);
-                    continue;
-                }
-
-                var microwavedComp = AddComp<ActivelyMicrowavedComponent>(item);
-                microwavedComp.Microwave = uid;
-
-                string? solidID = null;
-                int amountToAdd = 1;
-
-                // If a microwave recipe uses a stacked item, use the default stack prototype id instead of prototype id
-                if (TryComp<StackComponent>(item, out var stackComp))
-                {
-                    solidID = ProtoMan.Index<StackPrototype>(stackComp.StackTypeId).Spawn;
-                    amountToAdd = stackComp.Count;
-                }
-                else
-                {
-                    var metaData = MetaData(item); //this simply begs for cooking refactor
-                    if (metaData.EntityPrototype is not null)
-                        solidID = metaData.EntityPrototype.ID;
-                }
-
-                if (solidID is null)
-                    continue;
-
-                if (!solidsDict.TryAdd(solidID, amountToAdd))
-                    solidsDict[solidID] += amountToAdd;
-
-                // only use reagents we have access to
-                // you have to break the eggs before we can use them!
-                if (!_solutionContainer.TryGetDrainableSolution(item, out var _, out var solution))
-                    continue;
-
-                foreach (var (reagent, quantity) in solution.Contents)
-                {
-                    if (!reagentDict.TryAdd(reagent.Prototype, quantity))
-                        reagentDict[reagent.Prototype] += quantity;
-                }
-            }
-
-            // Check recipes
-            var getRecipesEv = new GetSecretRecipesEvent();
-            RaiseLocalEvent(uid, ref getRecipesEv);
-
-            List<FoodRecipePrototype> recipes = getRecipesEv.Recipes;
-            recipes.AddRange(_recipeManager.Recipes);
-            var portionedRecipe = recipes.Select(r =>
-                CanSatisfyRecipe(component, r, solidsDict, reagentDict)).FirstOrDefault(r => r.Item2 > 0);
-
-            _audio.PlayPvs(component.StartCookingSound, uid);
-            var activeComp = AddComp<ActiveMicrowaveComponent>(uid); //microwave is now cooking
-            activeComp.CookTimeRemaining = component.CurrentCookTimerTime * component.CookTimeMultiplier;
-            activeComp.TotalTime = component.CurrentCookTimerTime; //this doesn't scale so that we can have the "actual" time
-            activeComp.PortionedRecipe = portionedRecipe;
-            //Scale tiems with cook times
-            component.CurrentCookTimeEnd = _gameTiming.CurTime + TimeSpan.FromSeconds(component.CurrentCookTimerTime * component.CookTimeMultiplier);
-            if (malfunctioning)
-                activeComp.MalfunctionTime = _gameTiming.CurTime + TimeSpan.FromSeconds(component.MalfunctionInterval);
-            UpdateUserInterfaceState(uid, component);
-        }
-
-        private void StopCooking(Entity<MicrowaveComponent> ent)
-        {
-            RemCompDeferred<ActiveMicrowaveComponent>(ent);
-            foreach (var solid in ent.Comp.Storage.ContainedEntities)
-            {
-                RemCompDeferred<ActivelyMicrowavedComponent>(solid);
-            }
-        }
-
-        public static (FoodRecipePrototype, int) CanSatisfyRecipe(MicrowaveComponent component, FoodRecipePrototype recipe, Dictionary<string, int> solids, Dictionary<string, FixedPoint2> reagents)
-        {
-            var portions = 0;
-
-            if (component.CurrentCookTimerTime % recipe.CookTime != 0)
-            {
-                //can't be a multiple of this recipe
-                return (recipe, 0);
-            }
-
-            foreach (var solid in recipe.IngredientsSolids)
-            {
-                if (!solids.ContainsKey(solid.Key))
-                    return (recipe, 0);
-
-                if (solids[solid.Key] < solid.Value)
-                    return (recipe, 0);
-
-                portions = portions == 0
-                    ? solids[solid.Key] / solid.Value.Int()
-                    : Math.Min(portions, solids[solid.Key] / solid.Value.Int());
-            }
-
-            foreach (var reagent in recipe.IngredientsReagents)
-            {
-                // TODO Turn recipe.IngredientsReagents into a ReagentQuantity[]
-                if (!reagents.ContainsKey(reagent.Key))
-                    return (recipe, 0);
-
-                if (reagents[reagent.Key] < reagent.Value)
-                    return (recipe, 0);
-
-                portions = portions == 0
-                    ? reagents[reagent.Key].Int() / reagent.Value.Int()
-                    : Math.Min(portions, reagents[reagent.Key].Int() / reagent.Value.Int());
-            }
-
-            //cook only as many of those portions as time allows
-            return (recipe, (int) Math.Min(portions, component.CurrentCookTimerTime / recipe.CookTime));
-        }
-
-        public override void Update(float frameTime)
-        {
-            base.Update(frameTime);
-
-            var query = EntityQueryEnumerator<ActiveMicrowaveComponent, MicrowaveComponent>();
-            while (query.MoveNext(out var uid, out var active, out var microwave))
-            {
-
-                active.CookTimeRemaining -= frameTime;
-
-                RollMalfunction((uid, active, microwave));
-
-                //check if there's still cook time left
-                if (active.CookTimeRemaining > 0)
-                {
-                    AddTemperature(microwave, frameTime);
-                    continue;
-                }
-
-                //this means the microwave has finished cooking.
-                AddTemperature(microwave, Math.Max(frameTime + active.CookTimeRemaining, 0)); //Though there's still a little bit more heat to pump out
-
-                if (active.PortionedRecipe.Item1 != null)
-                {
-                    var coords = Transform(uid).Coordinates;
-                    for (var i = 0; i < active.PortionedRecipe.Item2; i++)
-                    {
-                        SubtractContents(microwave, active.PortionedRecipe.Item1);
-                        Spawn(active.PortionedRecipe.Item1.Result, coords);
-                    }
-                }
-
-                _container.EmptyContainer(microwave.Storage);
-                microwave.CurrentCookTimeEnd = TimeSpan.Zero;
-                UpdateUserInterfaceState(uid, microwave);
-                _audio.PlayPvs(microwave.FoodDoneSound, uid);
-                StopCooking((uid, microwave));
-            }
-        }
-
-        /// <summary>
-        /// This event tries to get secret recipes that the microwave might be capable of.
-        /// Currently, we only check the microwave itself, but in the future, the user might be able to learn recipes.
-        /// </summary>
-        private void OnGetSecretRecipes(Entity<FoodRecipeProviderComponent> ent, ref GetSecretRecipesEvent args)
-        {
-            foreach (ProtoId<FoodRecipePrototype> recipeId in ent.Comp.ProvidedRecipes)
-            {
-                if (ProtoMan.Resolve(recipeId, out var recipeProto))
-                {
-                    args.Recipes.Add(recipeProto);
-                }
-            }
-        }
-
-        #region ui
-        private void OnEjectMessage(Entity<MicrowaveComponent> ent, ref MicrowaveEjectMessage args)
-        {
-            if (!HasContents(ent.Comp) || HasComp<ActiveMicrowaveComponent>(ent))
-                return;
-
-            _container.EmptyContainer(ent.Comp.Storage);
-            var audioParams = ent.Comp.ClickSound?.Params ?? AudioParams.Default;
-            audioParams = audioParams.AddVolume(-2);
-            _audio.PlayPvs(ent.Comp.ClickSound, ent, audioParams);
-            UpdateUserInterfaceState(ent, ent.Comp);
-        }
-
-        private void OnEjectIndex(Entity<MicrowaveComponent> ent, ref MicrowaveEjectSolidIndexedMessage args)
-        {
-            if (!HasContents(ent.Comp) || HasComp<ActiveMicrowaveComponent>(ent))
-                return;
-
-            _container.Remove(GetEntity(args.EntityID), ent.Comp.Storage);
-            UpdateUserInterfaceState(ent, ent.Comp);
-        }
-
-        private void OnSelectTime(Entity<MicrowaveComponent> ent, ref MicrowaveSelectCookTimeMessage args)
-        {
-            if (!HasContents(ent.Comp) || HasComp<ActiveMicrowaveComponent>(ent) || !(TryComp<ApcPowerReceiverComponent>(ent, out var apc) && apc.Powered))
-                return;
-
-            // some validation to prevent trollage
-            if (args.NewCookTime % 5 != 0 || args.NewCookTime > ent.Comp.MaxCookTime)
-                return;
-
-            ent.Comp.CurrentCookTimeButtonIndex = args.ButtonIndex;
-            ent.Comp.CurrentCookTimerTime = args.NewCookTime;
-            ent.Comp.CurrentCookTimeEnd = TimeSpan.Zero;
-            var audioParams = ent.Comp.ClickSound?.Params ?? AudioParams.Default;
-            audioParams = audioParams.AddVolume(-2);
-            _audio.PlayPvs(ent.Comp.ClickSound, ent, audioParams);
-            UpdateUserInterfaceState(ent, ent.Comp);
-        }
-        #endregion
-    }
-}
diff --git a/Content.Server/Kitchen/EntitySystems/ServerMicrowaveSystem.cs b/Content.Server/Kitchen/EntitySystems/ServerMicrowaveSystem.cs
new file mode 100644
index 0000000000..c306b45dcd
--- /dev/null
+++ b/Content.Server/Kitchen/EntitySystems/ServerMicrowaveSystem.cs
@@ -0,0 +1,115 @@
+using Content.Server.Administration.Logs;
+using Content.Server.Construction;
+using Content.Server.Construction.Components;
+using Content.Server.Explosion.EntitySystems;
+using Content.Server.Lightning;
+using Content.Shared.Damage.Components;
+using Content.Shared.Database;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Kitchen.EntitySystems;
+using Content.Shared.Suicide;
+using Robust.Shared.Player;
+using Robust.Shared.Random;
+
+namespace Content.Server.Kitchen.EntitySystems;
+
+/// <inheritdoc />
+public sealed partial class ServerMicrowaveSystem : MicrowaveSystem
+{
+    [Dependency] private IAdminLogManager _adminLogger = default!;
+    [Dependency] private ExplosionSystem _explosion = default!;
+    [Dependency] private LightningSystem _lightning = default!;
+    [Dependency] private IRobustRandom _random = default!;
+    [Dependency] private SharedSuicideSystem _suicide = default!;
+
+    [Dependency] private EntityQuery<DamageableComponent> _damageableQuery;
+    [Dependency] private EntityQuery<MachineComponent> _machineQuery;
+
+    /// <summary>
+    /// Kills the user by microwaving their head.
+    /// </summary>
+    /// <remarks>
+    /// TODO: Make this not awful, it keeps any items attached to your head still on and you can
+    /// revive someone and cogni them so you have some dumb headless fuck running around. I've seen it happen.
+    /// </remarks>
+    [SubscribeLocalEvent]
+    private void OnSuicideByEnvironment(Entity<MicrowaveComponent> ent, ref SuicideByEnvironmentEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        // The act of getting your head microwaved doesn't actually kill you
+        if (!_damageableQuery.TryComp(args.Victim, out var damageableComponent))
+            return;
+
+        // The application of lethal damage is what kills you...
+        _suicide.ApplyLethalDamage((args.Victim, damageableComponent), "Heat");
+
+        var victim = args.Victim;
+        var othersMessage = Loc.GetString("microwave-component-suicide-others-message", ("victim", victim));
+        var selfMessage = Loc.GetString("microwave-component-suicide-message");
+
+        Popup.PopupEntity(othersMessage, victim, Filter.PvsExcept(victim), true);
+        Popup.PopupEntity(selfMessage, victim, victim);
+
+        var audioParams = ent.Comp.ClickSound.Params;
+        Audio.PlayPvs(ent.Comp.ClickSound, ent.Owner, audioParams);
+
+        ent.Comp.CurrentCookTimerTime = 10;
+        DirtyField(ent.AsNullable(), nameof(ent.Comp.CurrentCookTimeButtonIndex));
+        StartCooking(ent, args.Victim);
+        UpdateUI(ent.AsNullable());
+        args.Handled = true;
+    }
+
+    /// <summary>
+    /// Prevents construction graph operations as a result of temperature changes.
+    /// </summary>
+    /// <remarks>
+    /// For example: raw meat will not turn into steak while it is actively being microwaved.
+    /// </remarks>
+    [SubscribeLocalEvent]
+    private void OnConstructionTemp(Entity<ActivelyMicrowavedComponent> ent, ref OnConstructionTemperatureEvent args)
+    {
+        args.Result = HandleResult.False;
+    }
+
+    /// <inheritdoc />
+    protected override void RollMalfunction(Entity<MicrowaveComponent> ent)
+    {
+        base.RollMalfunction(ent);
+
+        // this microwave sploded
+        if (ent.Comp.Broken)
+            return;
+
+        var comp = ent.Comp;
+        if (_random.Prob(comp.LightningChance))
+            _lightning.ShootRandomLightnings(ent, 1.0f, 2, comp.MalfunctionSpark, triggerLightningEvents: false);
+    }
+
+    /// <summary>
+    /// Explodes the microwave internally, turning it into a broken state, destroying its board, and spitting out its machine parts
+    /// </summary>
+    /// <param name="ent">The microwave entity.</param>
+    public override void Explode(Entity<MicrowaveComponent?> ent)
+    {
+        base.Explode(ent);
+
+        if (!Resolve(ent.Owner, ref ent.Comp))
+            return;
+
+        _explosion.TriggerExplosive(ent);
+
+        if (_machineQuery.TryComp(ent, out var machine))
+        {
+            Container.CleanContainer(machine.BoardContainer);
+            Container.EmptyContainer(machine.PartContainer);
+        }
+
+        _adminLogger.Add(LogType.Action,
+            LogImpact.Medium,
+            $"{ToPrettyString(ent)} exploded from unsafe cooking!");
+    }
+}
diff --git a/Content.Shared/Kitchen/Components/ActiveMicrowaveComponent.cs b/Content.Shared/Kitchen/Components/ActiveMicrowaveComponent.cs
new file mode 100644
index 0000000000..430b0cfec3
--- /dev/null
+++ b/Content.Shared/Kitchen/Components/ActiveMicrowaveComponent.cs
@@ -0,0 +1,88 @@
+using Content.Shared.Kitchen.EntitySystems;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Shared.Kitchen.Components;
+
+/// <summary>
+/// Attached to a microwave that is currently in the process of cooking
+/// </summary>
+[RegisterComponent]
+[Access(typeof(MicrowaveSystem))]
+[NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true), AutoGenerateComponentPause]
+public sealed partial class ActiveMicrowaveComponent : Component
+{
+    /// <summary>
+    /// Whether or not this microwave cooking process is malfunctioning.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Malfunctioning;
+
+    /// <summary>
+    /// The recipe we are currently cooking.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public PortionedRecipe? PortionedRecipe;
+
+    /// <summary>
+    /// The total cooking time of this operation.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float TotalTime;
+
+    /// <summary>
+    /// The time that this microwave will finish cooking.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    [AutoNetworkedField, AutoPausedField]
+    public TimeSpan CookTimeEnd = TimeSpan.Zero;
+
+    /// <summary>
+    /// The last time that this microwave updated its cooking cycle..
+    /// </summary>
+    /// <remarks>
+    /// This is used to calculate how much heat to add to the microwave.
+    /// </remarks>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    [AutoNetworkedField, AutoPausedField]
+    public TimeSpan LastCookUpdated = TimeSpan.Zero;
+
+    /// <summary>
+    /// The next time this microwave will update its cooking cycle.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    [AutoNetworkedField, AutoPausedField]
+    public TimeSpan NextCookUpdate = TimeSpan.Zero;
+
+    /// <summary>
+    /// The next time we attempt to roll a malfunction.
+    /// </summary>
+    /// <remarks>
+    /// Malfunctions are rolled on an interval and generate random effects, like lightning or microwave destruction.
+    /// </remarks>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    [AutoNetworkedField, AutoPausedField]
+    public TimeSpan NextMalfunction = TimeSpan.Zero;
+}
+
+/// <summary>
+/// Represents a specific quantity of a recipe to cook.
+/// </summary>
+[Serializable, NetSerializable]
+[DataDefinition]
+public partial struct PortionedRecipe(ProtoId<MicrowaveMealRecipePrototype> recipe, uint count)
+{
+    /// <summary>
+    /// The recipe to make.
+    /// </summary>
+    [DataField]
+    public ProtoId<MicrowaveMealRecipePrototype> Recipe = recipe;
+
+    /// <summary>
+    /// The number of portions to make of this recipe.
+    /// </summary>
+    [DataField]
+    public uint Count = count;
+}
diff --git a/Content.Server/Kitchen/Components/ActivelyMicrowavedComponent.cs b/Content.Shared/Kitchen/Components/ActivelyMicrowavedComponent.cs
similarity index 66%
rename from Content.Server/Kitchen/Components/ActivelyMicrowavedComponent.cs
rename to Content.Shared/Kitchen/Components/ActivelyMicrowavedComponent.cs
index c7fca5a47e..7da66ba453 100644
--- a/Content.Server/Kitchen/Components/ActivelyMicrowavedComponent.cs
+++ b/Content.Shared/Kitchen/Components/ActivelyMicrowavedComponent.cs
@@ -1,14 +1,17 @@
-namespace Content.Server.Kitchen.Components;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Kitchen.Components;
 
 /// <summary>
 /// Attached to an object that's actively being microwaved
 /// </summary>
 [RegisterComponent]
+[NetworkedComponent, AutoGenerateComponentState]
 public sealed partial class ActivelyMicrowavedComponent : Component
 {
     /// <summary>
     /// The microwave this entity is actively being microwaved by.
     /// </summary>
-    [DataField]
+    [DataField, AutoNetworkedField]
     public EntityUid? Microwave;
 }
diff --git a/Content.Shared/Kitchen/Components/MicrowaveComponent.cs b/Content.Shared/Kitchen/Components/MicrowaveComponent.cs
new file mode 100644
index 0000000000..b01350e587
--- /dev/null
+++ b/Content.Shared/Kitchen/Components/MicrowaveComponent.cs
@@ -0,0 +1,231 @@
+using Content.Shared.DeviceLinking;
+using Content.Shared.Item;
+using Content.Shared.Kitchen.EntitySystems;
+using Content.Shared.Temperature.Components;
+using Content.Shared.Whitelist;
+using Robust.Shared.Audio;
+using Robust.Shared.Containers;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Kitchen.Components;
+
+/// <summary>
+/// A component applied to microwaves, which are used to heat entities/solutions
+/// and produce microwave recipes.
+/// </summary>
+[RegisterComponent]
+[Access(typeof(MicrowaveSystem))]
+[NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true, raiseAfterAutoHandleState: true)]
+public sealed partial class MicrowaveComponent : Component
+{
+    /// <summary>
+    /// A multiplier applied to all microwave cooking timers.
+    /// </summary>
+    /// <remarks>
+    /// If you set a microwave for 30 seconds, but have a CookTimeMultiplier of 0.5,
+    /// recipes will be processed as if you're portioning for 30 seconds, but the
+    /// microwave's timer will take 15 seconds instead. So, if you have a recipe with
+    /// a cookTime of 10 seconds, you can still make that recipe 3 at a time.
+    ///
+    /// Note that faster cooking times make the microwave less useful for actual heating
+    /// (temperature) as thermal energy added to the contents is based on elapsed time.
+    /// </remarks>
+    [DataField]
+    public float CookTimeMultiplier = 1;
+
+    /// <summary>
+    /// A multiplier for heat added to the contents of a microwave every cook cycle.
+    /// </summary>
+    /// <remarks>
+    /// The formula is (elapsed time between dt * <see cref="DeltaHeat"/>).
+    /// </remarks>
+    [DataField]
+    public float DeltaHeat = 100;
+
+    /// <summary>
+    /// A multiplier for added heat on entities with a <see cref="TemperatureComponent"/>.
+    /// </summary>
+    [DataField]
+    public float ObjectHeatMultiplier = 100;
+
+    /// <summary>
+    /// An entity that is produced when an item is melted in the microwave.
+    /// </summary>
+    /// <remarks>
+    /// The microwave will burn items that pass the <see cref="BurnWhenCookedWhitelist" />.
+    /// </remarks>
+    [DataField]
+    public EntProtoId FailureResult = "FoodBadRecipe";
+
+    #region Audio
+
+    /// <summary>
+    /// A sound that is played when the microwave is activated.
+    /// </summary>
+    [DataField]
+    public SoundSpecifier BeginCookingSound = new SoundPathSpecifier("/Audio/Machines/microwave_start_beep.ogg");
+
+    /// <summary>
+    /// A sound that is played when the microwave finishes.
+    /// </summary>
+    /// <remarks>
+    /// Beep... beep... beep
+    /// </remarks>
+    [DataField]
+    public SoundSpecifier FoodDoneSound = new SoundPathSpecifier("/Audio/Machines/microwave_done_beep.ogg");
+
+    /// <summary>
+    /// A sound that is played when a player navigates the microwave's UI - for example, selecting
+    /// a new cooking time.
+    /// </summary>
+    [DataField]
+    public SoundSpecifier ClickSound = new SoundPathSpecifier("/Audio/Machines/machine_switch.ogg")
+    {
+        Params = AudioParams.Default.AddVolume(-2),
+    };
+
+    /// <summary>
+    /// The humming sound played when a microwave is actively cooking.
+    /// </summary>
+    [DataField]
+    public SoundSpecifier LoopingSound = new SoundPathSpecifier("/Audio/Machines/microwave_loop.ogg");
+
+    #endregion Audio
+
+    /// <summary>
+    /// An audio stream for the microwave's "cooking" hum.
+    /// </summary>
+    [DataField]
+    public EntityUid? PlayingStream;
+
+    /// <summary>
+    /// Whether or not this microwave is broken.
+    /// </summary>
+    [DataField]
+    [AutoNetworkedField]
+    public bool Broken;
+
+    /// <summary>
+    /// A port used to activate the microwave via remote signal.
+    /// </summary>
+    [DataField]
+    public ProtoId<SinkPortPrototype> OnPort = "On";
+
+    /// <summary>
+    /// The currently-selected cook time, in seconds. This must be a multiple of 5 (or 0).
+    /// </summary>
+    /// <remarks>
+    /// The cook times for all recipes should be divisible by 5, with a minimum of 1 second.
+    /// For right now, I don't think any recipe cook time should be greater than 60 seconds.
+    /// </remarks>
+    [DataField]
+    [AutoNetworkedField]
+    [Access(typeof(MicrowaveSystem), Other = AccessPermissions.ReadExecute)]
+    public uint CurrentCookTimerTime;
+
+    /// <summary>
+    /// The index of the currently-selected "cook time" button.
+    /// </summary>
+    [DataField]
+    [AutoNetworkedField]
+    public int CurrentCookTimeButtonIndex;
+
+    /// <summary>
+    /// The maximum number of seconds a microwave can be set to.
+    /// This is currently only used for validation and the client does not check this.
+    /// </summary>
+    [DataField]
+    public uint MaxCookTime = 30;
+
+    /// <summary>
+    /// The max temperature that this microwave can heat objects to.
+    /// </summary>
+    [DataField]
+    public float TemperatureUpperThreshold = 373.15f;
+
+    /// <summary>
+    /// The microwave's contents container.
+    /// </summary>
+    public Container Storage = default!;
+
+    /// <summary>
+    /// The ID of the storage container for the microwave.
+    /// </summary>
+    [DataField]
+    public string ContainerId = "microwave_entity_container";
+
+    /// <summary>
+    /// How many items the microwave can hold.
+    /// </summary>
+    [DataField]
+    public int Capacity = 10;
+
+    /// <summary>
+    /// The largest item size that can fit in the microwave.
+    /// </summary>
+    [DataField]
+    public ProtoId<ItemSizePrototype> MaxItemSize = "Normal";
+
+    /// <summary>
+    /// How frequently the microwave can malfunction while active.
+    /// </summary>
+    [DataField]
+    public TimeSpan MalfunctionInterval = TimeSpan.FromSeconds(1.0f);
+
+    /// <summary>
+    /// How frequently the microwave can update (process cooking cycle) while active.
+    /// </summary>
+    [DataField]
+    public TimeSpan UpdateInterval = TimeSpan.FromSeconds(1.0f);
+
+    /// <summary>
+    /// Chance of an explosion occurring when we microwave a metallic object.
+    /// </summary>
+    /// <remarks>
+    /// This is rolled every <see cref="MalfunctionInterval"/>.
+    /// </remarks>
+    [DataField]
+    public float ExplosionChance = 0.1f;
+
+    /// <summary>
+    /// Chance of lightning occurring when we microwave a metallic object.
+    /// </summary>
+    /// <remarks>
+    /// This is rolled every <see cref="MalfunctionInterval"/>.
+    /// </remarks>
+    [DataField]
+    public float LightningChance = 0.75f;
+
+    /// <summary>
+    /// If this microwave can give ID cards new accesses without exploding.
+    /// </summary>
+    [DataField]
+    public bool CanMicrowaveIdsSafely = true;
+
+    /// <summary>
+    /// Entities that fulfill this whitelist will cause the microwave to malfunction
+    /// on activation. By default, this is metal objects.
+    /// </summary>
+    [DataField]
+    public EntityWhitelist? MalfunctionWhenCookedWhitelist = new()
+    {
+        Tags = new() { "Metal" }
+    };
+
+    /// <summary>
+    /// Entities that fulfill this whitelist will create a burned mess when microwaved.
+    /// By default, this is plastic objects.
+    /// </summary>
+    [DataField]
+    public EntityWhitelist? BurnWhenCookedWhitelist = new()
+    {
+        Tags = new() { "Plastic" }
+    };
+
+    /// <summary>
+    /// A "spark" entity spawned when this microwave malfunctions.
+    /// </summary>
+    [DataField]
+    public EntProtoId MalfunctionSpark = "Spark";
+}
diff --git a/Content.Shared/Kitchen/Components/RecipeProviderComponent.cs b/Content.Shared/Kitchen/Components/RecipeProviderComponent.cs
index d677e42674..fe44f66dd0 100644
--- a/Content.Shared/Kitchen/Components/RecipeProviderComponent.cs
+++ b/Content.Shared/Kitchen/Components/RecipeProviderComponent.cs
@@ -2,6 +2,10 @@ using Robust.Shared.Prototypes;
 
 namespace Content.Shared.Kitchen.Components;
 
+/// <summary>
+/// Applied to entities that have access to secret microwave recipes.
+/// See: <see cref="MicrowaveMealRecipePrototype.SecretRecipe"/>
+/// </summary>
 [RegisterComponent]
 public sealed partial class FoodRecipeProviderComponent : Component
 {
@@ -9,5 +13,5 @@ public sealed partial class FoodRecipeProviderComponent : Component
     /// These are additional recipes that the entity is capable of cooking.
     /// </summary>
     [DataField, ViewVariables]
-    public List<ProtoId<FoodRecipePrototype>> ProvidedRecipes = new();
+    public List<ProtoId<MicrowaveMealRecipePrototype>> ProvidedRecipes = new();
 }
diff --git a/Content.Shared/Kitchen/Components/SharedMicrowave.cs b/Content.Shared/Kitchen/Components/SharedMicrowave.cs
deleted file mode 100644
index fa12368984..0000000000
--- a/Content.Shared/Kitchen/Components/SharedMicrowave.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-using Content.Shared.Chemistry.Reagent;
-using Robust.Shared.Serialization;
-
-namespace Content.Shared.Kitchen.Components
-{
-    [Serializable, NetSerializable]
-    public sealed class MicrowaveStartCookMessage : BoundUserInterfaceMessage
-    {
-    }
-
-    [Serializable, NetSerializable]
-    public sealed class MicrowaveEjectMessage : BoundUserInterfaceMessage
-    {
-
-    }
-
-    [Serializable, NetSerializable]
-    public sealed class MicrowaveEjectSolidIndexedMessage : BoundUserInterfaceMessage
-    {
-        public NetEntity EntityID;
-        public MicrowaveEjectSolidIndexedMessage(NetEntity entityId)
-        {
-            EntityID = entityId;
-        }
-    }
-
-    [Serializable, NetSerializable]
-    public sealed class MicrowaveVaporizeReagentIndexedMessage : BoundUserInterfaceMessage
-    {
-        public ReagentQuantity ReagentQuantity;
-        public MicrowaveVaporizeReagentIndexedMessage(ReagentQuantity reagentQuantity)
-        {
-            ReagentQuantity = reagentQuantity;
-        }
-    }
-
-    [Serializable, NetSerializable]
-    public sealed class MicrowaveSelectCookTimeMessage : BoundUserInterfaceMessage
-    {
-        public int ButtonIndex;
-        public uint NewCookTime;
-        public MicrowaveSelectCookTimeMessage(int buttonIndex, uint inputTime)
-        {
-            ButtonIndex = buttonIndex;
-            NewCookTime = inputTime;
-        }
-    }
-
-    [NetSerializable, Serializable]
-    public sealed class MicrowaveUpdateUserInterfaceState : BoundUserInterfaceState
-    {
-        public NetEntity[] ContainedSolids;
-        public bool IsMicrowaveBusy;
-        public int ActiveButtonIndex;
-        public uint CurrentCookTime;
-
-        public TimeSpan CurrentCookTimeEnd;
-
-        public MicrowaveUpdateUserInterfaceState(NetEntity[] containedSolids,
-            bool isMicrowaveBusy, int activeButtonIndex, uint currentCookTime, TimeSpan currentCookTimeEnd)
-        {
-            ContainedSolids = containedSolids;
-            IsMicrowaveBusy = isMicrowaveBusy;
-            ActiveButtonIndex = activeButtonIndex;
-            CurrentCookTime = currentCookTime;
-            CurrentCookTimeEnd = currentCookTimeEnd;
-        }
-
-    }
-
-    [Serializable, NetSerializable]
-    public enum MicrowaveVisualState
-    {
-        Idle,
-        Cooking,
-        Broken,
-        Bloody
-    }
-
-    [NetSerializable, Serializable]
-    public enum MicrowaveUiKey
-    {
-        Key
-    }
-
-}
diff --git a/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.API.cs b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.API.cs
new file mode 100644
index 0000000000..c9f46df809
--- /dev/null
+++ b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.API.cs
@@ -0,0 +1,154 @@
+using System.Linq;
+using Content.Shared.Kitchen.Components;
+using JetBrains.Annotations;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Kitchen.EntitySystems;
+
+public abstract partial class MicrowaveSystem
+{
+    /// <summary>
+    /// Helper function to get if an entity is an active microwave.
+    /// </summary>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <returns>Whether or not this entity is an active microwave.</returns>
+    [PublicAPI]
+    public bool IsActiveMicrowave(Entity<MicrowaveComponent?> microwave)
+    {
+        return MicrowaveQuery.Resolve(microwave.Owner, ref microwave.Comp)
+            && ActiveMicrowaveQuery.HasComp(microwave.Owner);
+    }
+
+    /// <summary>
+    /// Helper function to get the contents of a microwave.
+    /// </summary>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <returns>A list of microwave contents.</returns>
+    [PublicAPI]
+    public IReadOnlyList<EntityUid> GetMicrowaveContents(Entity<MicrowaveComponent?> microwave)
+    {
+        if (!MicrowaveQuery.Resolve(microwave.Owner, ref microwave.Comp))
+            return new List<EntityUid>();
+
+        return microwave.Comp.Storage.ContainedEntities;
+    }
+
+    /// <summary>
+    /// Helper function to check if a microwave has ingredient contents.
+    /// </summary>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <returns>Whether or not this microwave contains anything.</returns>
+    [PublicAPI]
+    public bool HasContents(Entity<MicrowaveComponent?> microwave)
+    {
+        return GetMicrowaveContents(microwave).Any();
+    }
+
+    /// <summary>
+    /// Gets a complete ordered list of usable recipes for this appliance.
+    /// </summary>
+    /// <remarks>
+    /// Note that the order of recipes is meaningful. When a valid recipe is chosen, the first item
+    /// in the list that satisfies the conditions of the recipe is selected.
+    ///
+    /// Recipe prototypes in the recipe manager are pre-sorted based on complexity, so more "specific"
+    /// recipes will be selected first. Secret recipes come before all non-secret prototype recipes.
+    /// Do not sort the result of this function!
+    /// </remarks>
+    /// <param name="uid">The appliance to get recipes for.</param>
+    /// <returns>A complete list of usable recipe prototypes.</returns>
+    [PublicAPI]
+    public IReadOnlyList<MicrowaveMealRecipePrototype> GetAvailableRecipes(EntityUid uid)
+    {
+        var getRecipesEv = new GetSecretRecipesEvent();
+        RaiseLocalEvent(uid, ref getRecipesEv);
+
+        var recipes = getRecipesEv.Recipes
+            .OrderByDescending(recipe => recipe.Priority)
+            .ThenByDescending(recipe => recipe.Ingredients.Count())
+            .ToList();
+        recipes.AddRange(_recipes.Recipes);
+
+        return recipes;
+    }
+
+    /// <summary>
+    /// Given a recipe, a list of available ingredients, and a cooking time, this functions
+    /// gets how many times we can make this given recipe.
+    /// </summary>
+    /// <param name="recipe">A cooking recipe.</param>
+    /// <param name="ingredients">The ingredients we have available.</param>
+    /// <param name="cookTime">How long we are cooking for.</param>
+    /// <returns>How many portions of the recipe can be made.</returns>
+    [PublicAPI]
+    public static uint GetRecipePortions(MicrowaveMealRecipePrototype recipe,
+        CookingIngredients ingredients,
+        uint cookTime)
+    {
+        // Our cooking time must be a multiple of the recipe's cooking time.
+        // For example: If a recipe takes 10 seconds to cook, then you can't make it with a 15 second timer.
+        // However, if you use a 30 second timer, you could make three of that recipe on one timer.
+        if (cookTime % recipe.Time != 0)
+            return 0;
+
+        // TODO: there's actually a kind of nasty edge case microwave economics issue here,
+        // all reagents / stacks / solids will be included, but when the recipe is actually made,
+        // solids are used first, then stacks, then reagents.
+        // thus, recipe detection might thing you have "more" ingredients than you actually do.
+        //
+        // moral of the story: I hate microwaves
+        var portionCount = cookTime / recipe.Time;
+        var ingredientPortions = ingredients.PortionForRecipe(recipe.Ingredients);
+        portionCount = Math.Min(portionCount, ingredientPortions);
+
+        return portionCount;
+    }
+
+    /// <summary>
+    /// Given an appliance entity and a list of available ingredients, this function gets the first valid
+    /// usable recipe for cooking.
+    /// </summary>
+    /// <remarks>
+    /// The appliance entity itself is used to get secret recipes.
+    /// </remarks>
+    /// <param name="uid">An appliance to fetch a recipe for.</param>
+    /// <param name="ingredients">A list of available ingredients.</param>
+    /// <param name="cookTime">How long we plan to cook for.</param>
+    /// <returns>
+    /// The first valid recipe we can use. If there is none, this is (null, 0).
+    /// </returns>
+    [PublicAPI]
+    public PortionedRecipe? GetRecipe(EntityUid uid,
+        CookingIngredients ingredients,
+        uint cookTime)
+    {
+        var recipes = GetAvailableRecipes(uid);
+        var recipePortions = recipes.Select(recipe =>
+            {
+                var portions = GetRecipePortions(recipe, ingredients, cookTime);
+                return new PortionedRecipe(recipe.ID, portions);
+            });
+
+        return recipePortions.FirstOrNull(r => r.Count > 0)
+            ?? null;
+    }
+
+    /// <summary>
+    /// Gets a complete list of recipe-usable ingredients from a list of items, including solids,
+    /// stacks, and reagents.
+    /// </summary>
+    /// <param name="items">The list of items to use as ingredients.</param>
+    /// <returns>Cooking ingredient quantities representing the total usable ingredient list.</returns>
+    [PublicAPI]
+    public CookingIngredients GetTotalIngredients(List<EntityUid> items)
+    {
+        var ingredients = new CookingIngredients();
+
+        foreach (var item in items)
+        {
+            AddItemIngredients(item, ref ingredients);
+        }
+
+        return ingredients;
+    }
+}
diff --git a/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Active.cs b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Active.cs
new file mode 100644
index 0000000000..a730713911
--- /dev/null
+++ b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Active.cs
@@ -0,0 +1,123 @@
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reaction;
+using Content.Shared.Kitchen.Components;
+using Robust.Shared.Containers;
+
+namespace Content.Shared.Kitchen.EntitySystems;
+
+public abstract partial class MicrowaveSystem
+{
+    /// <summary>
+    /// Adjusts a microwave's visuals, audio, and power draw when activated.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnCookStart(Entity<ActiveMicrowaveComponent> ent, ref ComponentStartup args)
+    {
+        if (!MicrowaveQuery.TryComp(ent, out var microwaveComponent))
+            return;
+
+        ent.Comp.NextCookUpdate = Timing.CurTime + microwaveComponent.UpdateInterval;
+        ent.Comp.LastCookUpdated = Timing.CurTime;
+        DirtyFields(ent.AsNullable(), null, nameof(ent.Comp.NextCookUpdate), nameof(ent.Comp.LastCookUpdated));
+        ActivateMicrowaveCycle((ent, microwaveComponent));
+    }
+
+    /// <summary>
+    /// Adjusts a microwave's visuals, audio, and power draw when activated.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnCookEnd(Entity<ActiveMicrowaveComponent> ent, ref ComponentShutdown args)
+    {
+        if (!MicrowaveQuery.TryComp(ent, out var microwaveComponent))
+            return;
+
+        DeactivateMicrowaveCycle((ent, microwaveComponent));
+    }
+
+    /// <summary>
+    /// Adds ActivelyMicrowavedComponent to entities inserted into an active microwave.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnActiveMicrowaveInsert(Entity<ActiveMicrowaveComponent> ent, ref EntInsertedIntoContainerMessage args)
+    {
+        if (Timing.ApplyingState)
+            return;
+
+        BeginActivelyMicrowaving(args.Entity, ent.Owner);
+    }
+
+    /// <summary>
+    /// Removes ActivelyMicrowavedComponent from entities removed from an active microwave.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnActiveMicrowaveRemove(Entity<ActiveMicrowaveComponent> ent, ref EntRemovedFromContainerMessage args)
+    {
+        if (Timing.ApplyingState)
+            return;
+
+        RemCompDeferred<ActivelyMicrowavedComponent>(args.Entity);
+    }
+
+    /// <summary>
+    /// Prevents reagent reactions in entitites that are actively being microwaved.
+    /// </summary>
+    /// <remarks>
+    /// For example, raw egg would otherwise turn into cooked egg during the process, preventing it from being
+    /// "spent" when the microwave is finished cooking.
+    /// </remarks>
+    [SubscribeLocalEvent]
+    private void OnReactionAttempt(Entity<ActivelyMicrowavedComponent> ent, ref SolutionRelayEvent<ReactionAttemptEvent> args)
+    {
+        if (!ActiveMicrowaveQuery.TryComp(ent.Comp.Microwave, out var activeMicrowaveComp))
+            return;
+
+        var portionedRecipe = activeMicrowaveComp.PortionedRecipe;
+        if (portionedRecipe == null // no recipe selected
+            || !ProtoMan.TryIndex(portionedRecipe.Value.Recipe, out var recipe))
+            return;
+
+        var recipeReagents = recipe.Ingredients.Reagents.Keys;
+
+        foreach (var reagent in recipeReagents)
+        {
+            if (args.Event.Reaction.Reactants.ContainsKey(reagent))
+            {
+                args.Event.Cancelled = true;
+                return;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Adjusts a microwave's visuals, audio, and power draw when activated.
+    /// </summary>
+    protected virtual void ActivateMicrowaveCycle(Entity<MicrowaveComponent> ent)
+    {
+        SetAppearance(ent, MicrowaveVisualState.Cooking);
+        _powerState.SetWorkingState(ent.Owner, true);
+    }
+
+    /// <summary>
+    /// Adjusts a microwave's visuals, audio, and power draw when deactivated.
+    /// </summary>
+    protected virtual void DeactivateMicrowaveCycle(Entity<MicrowaveComponent> ent)
+    {
+        SetAppearance(ent, MicrowaveVisualState.Idle);
+        _powerState.SetWorkingState(ent.Owner, false);
+        foreach (var uid in GetMicrowaveContents(ent.AsNullable()))
+        {
+            RemCompDeferred<ActivelyMicrowavedComponent>(uid);
+        }
+    }
+
+    /// <summary>
+    /// Add ActivelyMicrowavedComponent to items that are being actively microwaved.
+    /// </summary>
+    /// <param name="uid">The entity being microwaved.</param>
+    /// <param name="microwave">That dastardly microwave</param>
+    private void BeginActivelyMicrowaving(EntityUid uid, EntityUid microwave)
+    {
+        var comp = new ActivelyMicrowavedComponent { Microwave = microwave };
+        AddComp(uid, comp);
+    }
+}
diff --git a/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Container.cs b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Container.cs
new file mode 100644
index 0000000000..fb30c41282
--- /dev/null
+++ b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Container.cs
@@ -0,0 +1,136 @@
+using Content.Shared.Construction.EntitySystems;
+using Content.Shared.Interaction;
+using Content.Shared.Item;
+using Content.Shared.Kitchen.Components;
+using Robust.Shared.Containers;
+
+namespace Content.Shared.Kitchen.EntitySystems;
+
+public abstract partial class MicrowaveSystem
+{
+    /// <summary>
+    /// Initializes the microwave's storage container.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnComponentInit(Entity<MicrowaveComponent> ent, ref ComponentInit args)
+    {
+        // this really does have to be in ComponentInit
+        ent.Comp.Storage = Container.EnsureContainer<Container>(ent, ent.Comp.ContainerId);
+    }
+
+    /// <summary>
+    /// Prevents inserting entities into the microwave if the microwave is broken, active,
+    /// or the item is invalid.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnInsertAttempt(Entity<MicrowaveComponent> ent, ref ContainerIsInsertingAttemptEvent args)
+    {
+        if (Timing.ApplyingState)
+            return;
+
+        if (args.Container.ID != ent.Comp.ContainerId)
+            return;
+
+        if (ent.Comp.Broken
+            || IsActiveMicrowave(ent.AsNullable())
+            || !CanFitInMicrowave(ent.AsNullable(), args.EntityUid))
+        {
+            args.Cancel();
+        }
+    }
+
+    /// <summary>
+    /// Attempt to insert an entity into the microwave, resulting in a pop-up message if this is not possible.
+    /// </summary>
+    [SubscribeLocalEvent(after:[typeof(AnchorableSystem)])]
+    private void OnInteractUsing(Entity<MicrowaveComponent> ent, ref InteractUsingEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        // Power is turned off
+        if (!_power.IsPowered(ent.Owner))
+        {
+            var message = Loc.GetString("microwave-component-interact-using-no-power");
+            Popup.PopupEntity(message, ent, args.User);
+            return;
+        }
+
+        // Microwave is broken
+        if (ent.Comp.Broken)
+        {
+            var message = Loc.GetString("microwave-component-interact-using-broken");
+            Popup.PopupEntity(message, ent, args.User);
+            return;
+        }
+
+        // Only items can be inserted into the microwave
+        if (!ItemQuery.TryComp(args.Used, out var item))
+        {
+            var message = Loc.GetString("microwave-component-interact-using-transfer-fail");
+            Popup.PopupEntity(message, ent, args.User);
+            return;
+        }
+
+        // Item is too big for the microwave
+        if (_item.GetSizePrototype(item.Size) > _item.GetSizePrototype(ent.Comp.MaxItemSize))
+        {
+            var message = Loc.GetString("microwave-component-interact-item-too-big", ("item", args.Used));
+            Popup.PopupEntity(message, ent, args.User);
+            return;
+        }
+
+        // The microwave is full
+        if (ent.Comp.Storage.Count >= ent.Comp.Capacity)
+        {
+            var message = Loc.GetString("microwave-component-interact-full");
+            Popup.PopupEntity(message, ent, args.User);
+            return;
+        }
+
+        _hands.TryDropIntoContainer(args.User, args.Used, ent.Comp.Storage);
+        args.Handled = true;
+    }
+    [SubscribeLocalEvent]
+    private void OnContentsAdded(Entity<MicrowaveComponent> entity, ref EntInsertedIntoContainerMessage args)
+        => OnContentsUpdated(entity, ref args);
+
+    [SubscribeLocalEvent]
+    private void OnContentsRemoved(Entity<MicrowaveComponent> entity, ref EntRemovedFromContainerMessage args)
+        => OnContentsUpdated(entity, ref args);
+
+    /// <summary>
+    /// Updates the microwave UI when entities are added/removed from the microwave.
+    /// </summary>
+    // For some reason ContainerModifiedMessage just can't be used at all with Entity<T>.
+    private void OnContentsUpdated<T>(Entity<MicrowaveComponent> entity, ref T args) where T : ContainerModifiedMessage
+    {
+        if (entity.Comp.Storage != args.Container)
+            return;
+
+        UpdateUI(entity.AsNullable());
+    }
+
+    /// <summary>
+    /// Check whether or not this microwave has space for the item, in both capacity and item size.
+    /// </summary>
+    /// <param name="ent">The microwave entity.</param>
+    /// <param name="item">The item to attempt to insert.</param>
+    /// <returns>Whether or not the item fits in the microwave. False if the item is too big or the microwave is full.</returns>
+    private bool CanFitInMicrowave(Entity<MicrowaveComponent?> ent, Entity<ItemComponent?> item)
+    {
+        if (!Resolve(ent.Owner, ref ent.Comp) || !Resolve(item.Owner, ref item.Comp))
+            return false;
+
+        var microwave = ent.Comp;
+        if (microwave.Storage.Count >= microwave.Capacity)
+            return false;
+
+        var maxSize = _item.GetSizePrototype(microwave.MaxItemSize);
+        var itemSize = _item.GetSizePrototype(item.Comp.Size);
+        if (itemSize > maxSize)
+            return false;
+
+        return true;
+    }
+}
diff --git a/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Cooking.cs b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Cooking.cs
new file mode 100644
index 0000000000..34a74547a1
--- /dev/null
+++ b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Cooking.cs
@@ -0,0 +1,285 @@
+using System.Linq;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Random.Helpers;
+
+namespace Content.Shared.Kitchen.EntitySystems;
+
+public abstract partial class MicrowaveSystem
+{
+    /// <summary>
+    /// Adds temperature to every item in the microwave based on the time it took to microwave.
+    /// </summary>
+    /// <param name="ent">The microwave entity.</param>
+    /// <param name="time">The heating time that has elapsed, in seconds.</param>
+    private void AddTemperature(Entity<MicrowaveComponent> ent, float time)
+    {
+        var component = ent.Comp;
+        var heatToAdd = time * component.DeltaHeat;
+        var objHeatToAdd = heatToAdd * component.ObjectHeatMultiplier;
+
+        // TODO: Divide heat amongst contents?
+        foreach (var entity in GetMicrowaveContents(ent.AsNullable()))
+        {
+            _temperature.ChangeHeat(entity, objHeatToAdd);
+
+            foreach (var (_, soln) in Solution.EnumerateSolutions(entity))
+            {
+                var solution = soln.Comp.Solution;
+                if (solution.Temperature > component.TemperatureUpperThreshold)
+                    continue;
+
+                Solution.AddThermalEnergy(soln, heatToAdd);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Attempts to roll random "malfunction" events on a malfunctioning microwave.
+    /// </summary>
+    protected virtual void RollMalfunction(Entity<MicrowaveComponent> ent)
+    {
+        if (SharedRandomExtensions.PredictedProb(Timing, ent.Comp.ExplosionChance, GetNetEntity(ent)))
+            Explode(ent.AsNullable());
+    }
+
+    public virtual void Explode(Entity<MicrowaveComponent?> ent)
+    {
+        if (!MicrowaveQuery.Resolve(ent.Owner, ref ent.Comp))
+            return;
+
+        ent.Comp.Broken = true;
+        DirtyField(ent.AsNullable(), nameof(ent.Comp.Broken));
+    }
+
+    /// <summary>
+    /// Start up the microwave. This processes each item in the microwave to experience microwave "on-cooking"
+    /// effects, attempts to retrieve a microwave recipe with its valid ingredients, and activates the
+    /// microwave visually.
+    /// </summary>
+    public void StartCooking(Entity<MicrowaveComponent> microwave, EntityUid? user)
+    {
+        if (!HasContents(microwave.AsNullable())
+            || IsActiveMicrowave(microwave.AsNullable())
+            || !_power.IsPowered(microwave.Owner))
+            return;
+
+        var contents = GetMicrowaveContents(microwave.AsNullable());
+        var malfunctioning = false;
+        var shouldContinue = TryStartMicrowavingContents(microwave,
+            contents,
+            user,
+            ref malfunctioning,
+            out var ingredientContents);
+
+        if (!shouldContinue)
+            return;
+
+        var ingredients = GetTotalIngredients(ingredientContents);
+        var cookTime = microwave.Comp.CurrentCookTimerTime;
+        var recipe = GetRecipe(microwave, ingredients, cookTime);
+
+        ActivateMicrowave(microwave, recipe, malfunctioning, user);
+    }
+
+    /// <summary>
+    /// Starts up the microwave cooking operation, setting the starting time and recipe of the microwave.
+    /// </summary>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <param name="recipe">The recipe and portion count associated with this operaton.</param>
+    /// <param name="malfunctioning">Whether or not this microwave is malfunctioning.</param>
+    /// <param name="user">The entity that is activating the microwave.</param>
+    private void ActivateMicrowave(Entity<MicrowaveComponent> microwave,
+        PortionedRecipe? recipe,
+        bool malfunctioning,
+        EntityUid? user)
+    {
+        var uid = microwave.Owner;
+        var component = microwave.Comp;
+        var curTime = Timing.CurTime;
+        var cookTime = component.CurrentCookTimerTime * component.CookTimeMultiplier;
+
+        Audio.PlayPredicted(component.BeginCookingSound, uid, user);
+
+        var activeComp = new ActiveMicrowaveComponent
+        {
+            PortionedRecipe = recipe,
+            TotalTime = component.CurrentCookTimerTime,
+            CookTimeEnd = curTime + TimeSpan.FromSeconds(cookTime),
+            Malfunctioning = malfunctioning,
+            NextMalfunction = malfunctioning
+                ? curTime + component.MalfunctionInterval
+                : TimeSpan.Zero,
+        };
+
+        AddComp(uid, activeComp);
+        UpdateUI(microwave.AsNullable());
+    }
+
+    /// <summary>
+    /// Iterates over the contents of a microwave and performs some on-microwaved effects.
+    /// Plastic items will melt and turn into burned messes.
+    /// Metal items will cause the microwave to malfunction.
+    /// </summary>
+    /// <remarks>
+    /// This also raises a BeingMicrowavedEvent on each item in the microwave. The result of
+    /// this event may cause us to exit early and proceed with cooking - for example, an
+    /// entity that causes the microwave to explode when microwaved.
+    ///
+    /// If cooking is not cancelled, the items inside will gain `ActiveMicrowaveComponent.`.
+    /// </remarks>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <param name="contents">The contents of the microwave.</param>
+    /// <param name="user">The entity that is activating the microwave.</param>
+    /// <param name="malfunctioning">Whether or not the microwave is malfunctioning.</param>
+    /// <param name="ingredientContents">A list of entities usable as ingredients.</param>
+    /// <returns>Wheteher or not we can proceed to use the microwave.</returns>
+    private bool TryStartMicrowavingContents(Entity<MicrowaveComponent> microwave,
+        IReadOnlyList<EntityUid> contents,
+        EntityUid? user,
+        ref bool malfunctioning,
+        out List<EntityUid> ingredientContents)
+    {
+        ingredientContents = contents.ToList();
+        foreach (var item in contents)
+        {
+            MicrowaveItem(microwave,
+                item,
+                user,
+                ref malfunctioning,
+                out var shouldExit,
+                out var shouldRemoveFromIngredients);
+
+            if (shouldExit)
+                return false;
+
+            if (shouldRemoveFromIngredients)
+                ingredientContents.Remove(item);
+        }
+
+        foreach (var item in ingredientContents)
+        {
+            BeginActivelyMicrowaving(item, microwave.Owner);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Processes a single entity in the microwave. This modifies / results in three
+    /// different parameters related to the operation: if the microwave should malfunction,
+    /// if the microwave should stop, and if the entity is still usable as an ingredient.
+    /// </summary>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <param name="item">The entity being microwaved.</param>
+    /// <param name="user">The entity activating the microwave.</param>
+    /// <param name="malfunctioning">Whether or not this microwave is malfunctioning.</param>
+    /// <param name="shouldStopMicrowave">Whether or not this microwave should stop.</param>
+    /// <param name="shouldRemoveFromIngredients">Whether or not this entity remains a valid ingredient.</param>
+    private void MicrowaveItem(Entity<MicrowaveComponent> microwave,
+        EntityUid item,
+        EntityUid? user,
+        ref bool malfunctioning,
+        out bool shouldStopMicrowave,
+        out bool shouldRemoveFromIngredients)
+    {
+        shouldStopMicrowave = false;
+        shouldRemoveFromIngredients = false;
+
+        // Special item-in-microwave interactions. Certain "being microwaved' interactions
+        // may cancel out any actual cooking, so this may early exit.
+        var beingMicrowaved = new BeingMicrowavedEvent(microwave.Owner, user);
+        RaiseLocalEvent(item, beingMicrowaved);
+
+        if (beingMicrowaved.Handled)
+        {
+            UpdateUI(microwave.AsNullable());
+            shouldStopMicrowave = true;
+            return;
+        }
+
+        if (_whitelist.IsWhitelistPass(microwave.Comp.MalfunctionWhenCookedWhitelist, item))
+            malfunctioning = true;
+
+        if (_whitelist.IsWhitelistPass(microwave.Comp.BurnWhenCookedWhitelist, item))
+        {
+            shouldRemoveFromIngredients = true;
+            CreateBurnedMess(microwave, item);
+        }
+    }
+
+    /// <summary>
+    /// Turns a single entity in the microwave into a failed "burned mess" recipe.
+    /// </summary>
+    /// <remarks>
+    /// This happens to entities that pass <see cref="MicrowaveComponent.BurnWhenCookedWhitelist"/>
+    /// when microwaved.
+    /// </remarks>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <param name="item">The entity to burn.</param>
+    private void CreateBurnedMess(Entity<MicrowaveComponent> microwave, EntityUid item)
+    {
+        var entProto = microwave.Comp.FailureResult;
+        var coords = Transform(microwave).Coordinates;
+        var junk = PredictedSpawnAtPosition(entProto, coords);
+        Container.Insert(junk, microwave.Comp.Storage);
+
+        PredictedDel(item);
+    }
+
+    /// <summary>
+    /// Completes a recipe in a microwave, removing its relevant ingredient contents
+    /// from the microwave and producing finished dish entities in their place.
+    /// </summary>
+    /// <param name="microwave">The microwave entity.</param>
+    /// <param name="portionedRecipe">The recipe we are using.</param>
+    private void SpawnFinishedRecipe(Entity<MicrowaveComponent> microwave, PortionedRecipe portionedRecipe)
+    {
+        SubtractContents(microwave, portionedRecipe);
+
+        var coords = Transform(microwave).Coordinates;
+        for (var i = 0; i < portionedRecipe.Count; i++)
+        {
+            if (!ProtoMan.Resolve(portionedRecipe.Recipe, out var recipe))
+                continue;
+
+            PredictedSpawnAtPosition(recipe.Result, coords);
+        }
+    }
+
+    /// <summary>
+    /// Finishes a cooking operation in the microwave, resulting in a finished food recipe,
+    /// the ejection of all remaining ingredients, and a sound cue.
+    /// </summary>
+    /// <param name="ent">The micorawve entity.</param>
+    private void CompleteCooking(Entity<ActiveMicrowaveComponent, MicrowaveComponent> ent)
+    {
+        var active = ent.Comp1;
+        var microwave = ent.Comp2;
+        var microwaveEnt = (ent.Owner, microwave);
+
+        // Spawn a finished recipe, if there is one.
+        if (active.PortionedRecipe != null)
+            SpawnFinishedRecipe(microwaveEnt, active.PortionedRecipe.Value);
+
+        // TODO: Audio prediction sucks. Predict this properly when audio prediction is less broken
+        // https://github.com/space-wizards/RobustToolbox/issues/6436
+        if (_net.IsServer)
+            Audio.PlayPvs(microwave.FoodDoneSound, ent); // beep... beep... beep
+
+        // Clean up the microwave.
+        Container.EmptyContainer(microwave.Storage);
+        StopCooking(microwaveEnt);
+    }
+
+    /// <summary>
+    /// Removes components from a microwave and its contents related to active microwave use.
+    /// </summary>
+    /// <remarks>
+    /// When the ActiveMicrowaveComponent is removed, it will trigger <see cref="OnCookEnd"/> on shutdown.
+    /// </remarks>
+    /// <param name="ent">The microwave entity.</param>
+    private void StopCooking(Entity<MicrowaveComponent> ent)
+    {
+        RemComp<ActiveMicrowaveComponent>(ent);
+    }
+}
diff --git a/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Recipes.cs b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Recipes.cs
new file mode 100644
index 0000000000..8379c88d5c
--- /dev/null
+++ b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.Recipes.cs
@@ -0,0 +1,282 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Stacks;
+using Robust.Shared.Containers;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Kitchen.EntitySystems;
+
+public abstract partial class MicrowaveSystem
+{
+    /// <summary>
+    /// This event tries to get secret recipes that the microwave might be capable of.
+    /// Currently, we only check the microwave itself, but in the future, the user might be able to learn recipes.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnGetSecretRecipes(Entity<FoodRecipeProviderComponent> ent, ref GetSecretRecipesEvent args)
+    {
+        foreach (var recipeId in ent.Comp.ProvidedRecipes)
+        {
+            if (ProtoMan.Resolve(recipeId, out var recipeProto))
+                args.Recipes.Add(recipeProto);
+        }
+    }
+
+    /// <summary>
+    /// Adds all usable ingredients from a given entity to an ingredient list.
+    /// </summary>
+    /// <remarks>
+    /// The entity itself is a "solid".
+    /// If it's a stack, then that stack is its "stacks".
+    /// If it has a usable ingredient solution, then the solution's contents are "reagents".
+    /// </remarks>
+    /// <param name="item">The entity to use as ingredients.</param>
+    /// <param name="ingredients">A dictionary of available ingredients to add to.</param>
+    private void AddItemIngredients(EntityUid item, ref CookingIngredients ingredients)
+    {
+        if (TryGetSolidId(item, out var solidId))
+            ingredients.AddSolid(solidId.Value);
+
+        if (StackQuery.TryComp(item, out var stack) && TryGetStackId(item, out var stackId))
+            ingredients.AddStack(stackId.Value, stack.Count);
+
+        if (TryGetUsableIngredientSolution(item, out _, out var solution))
+        {
+            foreach (var (reagent, quantity) in solution.Contents)
+            {
+                ingredients.AddReagent(reagent.Prototype, quantity);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Attempts to get a solution from an entity that can be used as viable ingredients in a recipe.
+    /// </summary>
+    /// <remarks>
+    /// For example, a beaker's contents will work, but not the contents of an uncracked egg.
+    /// </remarks>
+    /// <param name="uid">The entity to attempt to get a usable ingredient solution for.</param>
+    /// <param name="solutionEntity">A usable solution entity, if available.</param>
+    /// <param name="solution">A usable solution, if available.</param>
+    /// <returns>Whether or not a usable ingredient solution was successfully retrieved.</returns>
+    private bool TryGetUsableIngredientSolution(EntityUid uid,
+        [NotNullWhen(true)] out Entity<SolutionComponent>? solutionEntity,
+        [NotNullWhen(true)] out Solution? solution)
+    {
+        return Solution.TryGetDrainableSolution(uid, out solutionEntity, out solution);
+    }
+
+    /// <summary>
+    /// Given a dictionary of stacks that need to be spent in a recipe, and the amount of stacks
+    /// of a stack we have available, this function gets the number of stacks we need to remove
+    /// from the stack entity. It also removes this amount from the remaining stacks dictionary.
+    /// </summary>
+    /// <param name="availableStacks">How many stacks we have available.</param>
+    /// <param name="stackId">The stack ID associated with the stack.</param>
+    /// <param name="ingredientsToSpend">How many stacks  still need to be spent in the recipe.</param>
+    /// <returns>How many stacks we should remove from the available stack entity.</returns>
+    private static int SpendStackQuantity(int availableStacks,
+        ProtoId<StackPrototype> stackId,
+        CookingIngredients ingredientsToSpend)
+    {
+        if (!ingredientsToSpend.Stacks.TryGetValue(stackId, out var remaining))
+            return 0;
+
+        var spent = Math.Min(availableStacks, remaining);
+        ingredientsToSpend.AddStack(stackId, -spent);
+
+        return spent;
+    }
+
+    /// <summary>
+    /// Given a dictionary of reagents that need to be spent in a recipe, and a quantity of a reagent
+    /// that we have available in a solution, this function gets the amount of reagents we need to
+    /// remove from the solution. This also removes that amount from the "reagents to spend" dictionary.
+    /// </summary>
+    /// <param name="availableQuantity">How much reagent we have available.</param>
+    /// <param name="reagent">The ID of the reagent we are spending.</param>
+    /// <param name="ingredientsToSpend">A dictionary of reagents that still need to be spent.</param>
+    /// <returns>How much we should reduce the available reagent volume by.</returns>
+    private static FixedPoint2 SpendReagentQuantity(FixedPoint2 availableQuantity,
+        ProtoId<ReagentPrototype> reagent,
+        CookingIngredients ingredientsToSpend)
+    {
+        if (!ingredientsToSpend.Reagents.TryGetValue(reagent, out var remaining))
+            return 0;
+
+        var spent = FixedPoint2.Min(availableQuantity, remaining);
+        ingredientsToSpend.AddReagent(reagent, -spent);
+
+        return spent;
+    }
+
+    /// <summary>
+    /// Removes a solid ingredient that is used in a recipe, removing it from the dictionary of
+    /// remaining solids that still need to be spent in the recipe.
+    /// </summary>
+    /// <param name="item">The entity to remove.</param>
+    /// <param name="itemProto">The solid ID of the ingredient.</param>
+    /// <param name="container">The microwave's ingredient storage container.</param>
+    /// <param name="ingredientsToSpend">The struct representing ingredients we still need to spend.</param>
+    private void SubtractSolidContents(EntityUid item,
+        EntProtoId itemProto,
+        Container container,
+        CookingIngredients ingredientsToSpend)
+    {
+        if (!ingredientsToSpend.Solids.ContainsKey(itemProto))
+            return;
+
+        ingredientsToSpend.AddSolid(itemProto, -1);
+        Container.Remove(item, container);
+        PredictedQueueDel(item);
+    }
+
+    /// <summary>
+    /// Given a dictionary of remaining stacks that need to be spent in a recipe, this function
+    /// reduces a stack entity's count by however many stacks need to be spent. This also removes the
+    /// stack count from our remaining ingredients.
+    /// </summary>
+    /// <remarks>
+    /// If a recipe calls for two stacks of plasma sheets, and you put 5 sheets in the microwave, then
+    /// the plasma sheet stack would reduce by 2 (leaving you with 3 remaining), and plasma will
+    /// be removed from the remaining stacks dictionary.
+    /// </remarks>
+    /// <param name="ent">The stack entity.</param>
+    /// <param name="ingredientsToSpend">The struct representing ingredients we still need to spend.</param>
+    private void SubtractStackContents(Entity<StackComponent?> ent,
+        CookingIngredients ingredientsToSpend)
+    {
+        if (!Resolve(ent.Owner, ref ent.Comp))
+            return;
+
+        var stack = ent.Comp;
+        var stackId = stack.StackTypeId;
+        var startingQuantity = stack.Count;
+        var quantityToRemove = SpendStackQuantity(startingQuantity, stackId, ingredientsToSpend);
+
+        _stack.ReduceCount(ent.AsNullable(), quantityToRemove);
+    }
+
+    /// <summary>
+    /// Given a dictionary of remaining reagents that still need to be spent in a recipe, this function iterates
+    /// over a solution's contents and subtracts reagents according to the reagents to spend. This also removes
+    /// it from our remaining ingredients.
+    /// </summary>
+    /// <remarks>
+    /// Say you still have 6u mayonnaise remaining, and the solution has 10u mayonnaise, then 6u of
+    /// mayonnaise would be removed from the solution, leaving you with 4u left over. Then, mayonnaise
+    /// is removed from the dictionary of remaining reagents.
+    /// </remarks>
+    /// <param name="solutionEntity">The solution entity.</param>
+    /// <param name="solution">The solution itself.</param>
+    /// <param name="ingredientsToSpend">The struct representing ingredients we still need to spend.</param>
+    private void SubtractReagentContents(Entity<SolutionComponent> solutionEntity,
+        Solution solution,
+        CookingIngredients ingredientsToSpend)
+    {
+        var reagentsToProcess = ingredientsToSpend.Reagents.Keys.ToList();
+
+        foreach (var reagent in reagentsToProcess)
+        {
+            var availableQuantity = solution.GetTotalPrototypeQuantity(reagent);
+            if (availableQuantity == 0)
+                continue;
+
+            var quantityToRemove = SpendReagentQuantity(availableQuantity, reagent, ingredientsToSpend);
+            Solution.RemoveReagent(solutionEntity, reagent, quantityToRemove);
+        }
+    }
+
+    /// <summary>
+    /// Attempt to get the solid ID of a given entity.
+    /// </summary>
+    /// <param name="item">The entity to retrieve a solid ID for.</param>
+    /// <param name="solidId">The solid ID of the entity, if any.</param>
+    /// <returns>
+    /// Whether or not the solid ID was successfully retrieved. False if entity lacks an entity prototype ID.
+    /// </returns>
+    // TODO: Solids should be tag-based, or something like that. Not prototype-based.
+    private bool TryGetSolidId(EntityUid item,
+        [NotNullWhen(true)] out EntProtoId? solidId)
+    {
+        solidId = MetaData(item).EntityPrototype?.ID;
+        return solidId != null;
+    }
+
+    /// <summary>
+    /// Attempt to get the stack ID of a given entity.
+    /// </summary>
+    /// <param name="ent">The stack entity.</param>
+    /// <param name="stack">The stack prototype associated with this entity, if any.</param>
+    /// <returns>
+    /// Whether or not a stack ID is successfully retrieved. False if this entity is not a stack.
+    /// </returns>
+    private bool TryGetStackId(Entity<StackComponent?> ent,
+        [NotNullWhen(true)] out ProtoId<StackPrototype>? stack)
+    {
+        stack = null;
+
+        if (!Resolve(ent.Owner, ref ent.Comp, logMissing: false))
+            return false;
+
+        stack = ent.Comp.StackTypeId;
+        return true;
+    }
+
+    /// <summary>
+    /// Spend ingredients in the microwave based on a given recipe. This deletes ingredient entities (solids),
+    /// subtracts respective stack counts, and removes reagents from ingredient containers (reagents).
+    /// </summary>
+    /// <remarks>
+    /// This function does not check whether or not the contents have *enough* ingredients to
+    /// subtract - it simply performs the subtraction.
+    /// </remarks>
+    /// <param name="ent">The microwave entity.</param>
+    /// <param name="portionedRecipe">The recipe used to spend ingredients.</param>
+    private void SubtractContents(Entity<MicrowaveComponent> ent, PortionedRecipe portionedRecipe)
+    {
+        if (!ProtoMan.Resolve(portionedRecipe.Recipe, out var recipe))
+            return;
+
+        var ingredientsToSpend = recipe.Ingredients * portionedRecipe.Count;
+        var solidsToSpend = ingredientsToSpend.Solids;
+        var stacksToSpend = ingredientsToSpend.Stacks;
+        var reagentsToSpend = ingredientsToSpend.Reagents;
+        var microwave = ent.Comp;
+        var microwaveItems = GetMicrowaveContents(ent.AsNullable()).ToArray();
+
+        foreach (var item in microwaveItems)
+        {
+            if (solidsToSpend.Count > 0
+                && TryGetSolidId(item, out var solidId)
+                && solidsToSpend.ContainsKey(solidId.Value))
+            {
+                SubtractSolidContents(item, solidId.Value, microwave.Storage, ingredientsToSpend);
+                continue;
+                // We're exiting early here; if the solid ingredient is removed from the container,
+                // then we shouldn't be attempting to use its stack or reagents.
+            }
+
+            if (stacksToSpend.Count > 0
+                && StackQuery.TryComp(item, out var stack)
+                && TryGetStackId((item, stack), out var stackId)
+                && stacksToSpend.ContainsKey(stackId.Value))
+            {
+                SubtractStackContents((item, stack), ingredientsToSpend);
+                if (Deleted(item) || stack.Count <= 0)
+                    continue;
+                // We're exiting early here - if the stack is empty, then the stack entity
+                // is gonna be deleted. Which means we shouldn't be using its reagents.
+            }
+
+            if (reagentsToSpend.Count > 0
+                && TryGetUsableIngredientSolution(item, out var solutionEntity, out var solution)
+                && solution.Volume > 0)
+                SubtractReagentContents(solutionEntity.Value, solution, ingredientsToSpend);
+        }
+    }
+}
diff --git a/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.UI.cs b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.UI.cs
new file mode 100644
index 0000000000..41651db5a5
--- /dev/null
+++ b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.UI.cs
@@ -0,0 +1,120 @@
+using Content.Shared.Kitchen.Components;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Kitchen.EntitySystems;
+
+public abstract partial class MicrowaveSystem
+{
+    /// <summary>
+    /// Subscribe to UI-related events for microwaves.
+    /// </summary>
+    private void InitializeUI()
+    {
+        SubscribeLocalEvent<MicrowaveComponent, MicrowaveStartCookMessage>((e, ref m) => StartCooking(e, m.Actor));
+    }
+
+    /// <summary>
+    /// Ejects all ingredients from the microwave.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnEjectAll(Entity<MicrowaveComponent> ent, ref MicrowaveEjectMessage args)
+    {
+        if (!HasContents(ent.AsNullable()) || IsActiveMicrowave(ent.AsNullable()))
+            return;
+
+        Container.EmptyContainer(ent.Comp.Storage);
+
+        var audioParams = ent.Comp.ClickSound.Params;
+        audioParams = audioParams.AddVolume(-2);
+        Audio.PlayPredicted(ent.Comp.ClickSound, ent, args.Actor, audioParams);
+    }
+
+    /// <summary>
+    /// Ejects an ingredient entity from the microwave.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnEjectSolidIndexed(Entity<MicrowaveComponent> ent, ref MicrowaveEjectSolidIndexedMessage args)
+    {
+        if (!HasContents(ent.AsNullable()) || IsActiveMicrowave(ent.AsNullable()))
+            return;
+
+        Container.Remove(GetEntity(args.EntityId), ent.Comp.Storage);
+
+        var audioParams = ent.Comp.ClickSound.Params;
+        Audio.PlayPredicted(ent.Comp.ClickSound, ent, args.Actor, audioParams);
+    }
+
+    /// <summary>
+    /// Change the cook time of the microwave by selecting a new button index.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnSelectCookTime(Entity<MicrowaveComponent> ent, ref MicrowaveSelectCookTimeMessage args)
+    {
+        if (IsActiveMicrowave(ent.AsNullable())
+            || !_power.IsPowered(ent.Owner))
+            return;
+
+        // some validation to prevent trollage
+        if (args.NewCookTime % 5 != 0 || args.NewCookTime > ent.Comp.MaxCookTime)
+            return;
+
+        ent.Comp.CurrentCookTimeButtonIndex = args.ButtonIndex;
+        ent.Comp.CurrentCookTimerTime = args.NewCookTime;
+        Dirty(ent);
+
+        var audioParams = ent.Comp.ClickSound.Params;
+        Audio.PlayPredicted(ent.Comp.ClickSound, ent, args.Actor, audioParams);
+        UpdateUI(ent.AsNullable());
+    }
+
+    /// <summary>
+    /// Update the UI state of the microwave, including the microwave's current contents, cook time,
+    /// and whether or not it is actively cooking.
+    /// </summary>
+    /// <param name="microwave">The microwave to update.</param>
+    public virtual void UpdateUI(Entity<MicrowaveComponent?> microwave)
+    {
+
+    }
+}
+
+/// <summary>
+/// Sent from client to server to request the microwave to start cooking.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class MicrowaveStartCookMessage : BoundUserInterfaceMessage;
+
+/// <summary>
+/// Sent from client to server to request ejecting all contents of the microwave.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class MicrowaveEjectMessage : BoundUserInterfaceMessage;
+
+/// <summary>
+/// Sent from client to server to request ejecting an entity from the microwave.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class MicrowaveEjectSolidIndexedMessage(NetEntity entityId) : BoundUserInterfaceMessage
+{
+    /// <summary>
+    /// The entity to eject from the microwave.
+    /// </summary>
+    public NetEntity EntityId = entityId;
+}
+
+/// <summary>
+/// Sent from client to server to request changing the selected cook time button of the microwave.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class MicrowaveSelectCookTimeMessage(int buttonIndex, uint inputTime) : BoundUserInterfaceMessage
+{
+    /// <summary>
+    /// The index of the cook time button to select.
+    /// </summary>
+    public int ButtonIndex = buttonIndex;
+
+    /// <summary>
+    /// The cooking time associated with the newly-selected button.
+    /// </summary>
+    public uint NewCookTime = inputTime;
+}
diff --git a/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.cs b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.cs
new file mode 100644
index 0000000000..c8cded4141
--- /dev/null
+++ b/Content.Shared/Kitchen/EntitySystems/MicrowaveSystem.cs
@@ -0,0 +1,191 @@
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Destructible;
+using Content.Shared.DeviceLinking;
+using Content.Shared.DeviceLinking.Events;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Item;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Popups;
+using Content.Shared.Power;
+using Content.Shared.Power.EntitySystems;
+using Content.Shared.Stacks;
+using Content.Shared.Temperature.Systems;
+using Content.Shared.Whitelist;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Containers;
+using Robust.Shared.Network;
+using Robust.Shared.Serialization;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Kitchen.EntitySystems;
+
+/// <summary>
+/// A system that handles microwave logic, such as activation, malfunctions, and producing cooked recipes.
+/// TODO: Replace with a more sophisticated(?) cooking system.
+/// </summary>
+public abstract partial class MicrowaveSystem : EntitySystem
+{
+    [Dependency] protected IGameTiming Timing = default!;
+    [Dependency] protected SharedAppearanceSystem Appearance = default!;
+    [Dependency] protected SharedAudioSystem Audio = default!;
+    [Dependency] protected SharedContainerSystem Container = default!;
+    [Dependency] protected SharedPopupSystem Popup = default!;
+    [Dependency] protected SharedSolutionContainerSystem Solution = default!;
+
+    [Dependency] private INetManager _net = default!;
+    [Dependency] private EntityWhitelistSystem _whitelist = default!;
+    [Dependency] private RecipeSystem _recipes = default!;
+    [Dependency] private SharedDeviceLinkSystem _deviceLink = default!;
+    [Dependency] private SharedHandsSystem _hands = default!;
+    [Dependency] private SharedItemSystem _item = default!;
+    [Dependency] private SharedPowerReceiverSystem _power = default!;
+    [Dependency] private SharedPowerStateSystem _powerState = default!;
+    [Dependency] private SharedStackSystem _stack = default!;
+    [Dependency] private SharedTemperatureSystem _temperature = default!;
+
+    [Dependency] protected EntityQuery<MicrowaveComponent> MicrowaveQuery;
+    [Dependency] protected EntityQuery<ActiveMicrowaveComponent> ActiveMicrowaveQuery;
+    [Dependency] protected EntityQuery<ItemComponent> ItemQuery;
+    [Dependency] protected EntityQuery<StackComponent> StackQuery;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        InitializeUI();
+    }
+
+    /// <summary>
+    /// Processes every active microwave's ongoing cooking operation.
+    /// </summary>
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+        var curTime = Timing.CurTime;
+
+        var query = EntityQueryEnumerator<ActiveMicrowaveComponent, MicrowaveComponent>();
+        while (query.MoveNext(out var uid, out var active, out var microwave))
+        {
+            // Roll malfunctions
+            if (active.Malfunctioning && active.NextMalfunction < curTime)
+            {
+                active.NextMalfunction += microwave.MalfunctionInterval;
+                DirtyField(uid, active, nameof(active.NextMalfunction));
+
+                RollMalfunction((uid, microwave));
+            }
+
+            var timeSinceUpdate = curTime - active.LastCookUpdated;
+            var timeElapsed = (float)timeSinceUpdate.TotalSeconds;
+
+            // Finish cooking
+            if (active.CookTimeEnd < curTime)
+            {
+                AddTemperature((uid, microwave), timeElapsed);
+                CompleteCooking((uid, active, microwave));
+                continue;
+            }
+
+            // Otherwise, process the cooking cycle
+            if (active.NextCookUpdate > curTime)
+                continue;
+
+            active.NextCookUpdate += microwave.UpdateInterval;
+            active.LastCookUpdated = curTime;
+            DirtyFields(uid, active, null, nameof(active.NextCookUpdate), nameof(active.LastCookUpdated));
+            AddTemperature((uid, microwave), timeElapsed);
+        }
+    }
+
+    /// <summary>
+    /// Adds an "on" port to this microwave.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnMapInit(Entity<MicrowaveComponent> ent, ref MapInitEvent args)
+    {
+        _deviceLink.EnsureSinkPorts(ent, ent.Comp.OnPort);
+    }
+
+    /// <summary>
+    /// When a microwave is broken, its appearance changes and it stops being usable for cooking.
+    /// It will stop any ongoing cooking operations and empty its contents.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnBreak(Entity<MicrowaveComponent> ent, ref BreakageEventArgs args)
+    {
+        ent.Comp.Broken = true;
+        DirtyField(ent.AsNullable(), nameof(ent.Comp.Broken));
+        SetAppearance(ent, MicrowaveVisualState.Broken);
+
+        StopCooking(ent);
+        Container.EmptyContainer(ent.Comp.Storage);
+        UpdateUI(ent.AsNullable());
+    }
+
+    /// <summary>
+    /// Stop cooking if the microwave loses power.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnPowerChanged(Entity<MicrowaveComponent> ent, ref PowerChangedEvent args)
+    {
+        if (!args.Powered)
+        {
+            SetAppearance(ent, MicrowaveVisualState.Idle);
+            StopCooking(ent);
+        }
+
+        UpdateUI(ent.AsNullable());
+    }
+
+    /// <summary>
+    /// Empty the microwave if it is unanchored.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnAnchorChanged(Entity<MicrowaveComponent> ent, ref AnchorStateChangedEvent args)
+    {
+        if (!args.Anchored)
+            Container.EmptyContainer(ent.Comp.Storage);
+    }
+
+    /// <summary>
+    /// Turns the microwave on if its "on" port is activated.
+    /// </summary>
+    [SubscribeLocalEvent]
+    private void OnSignalReceived(Entity<MicrowaveComponent> ent, ref SignalReceivedEvent args)
+    {
+        if (ent.Comp.Broken || !_power.IsPowered(ent.Owner))
+            return;
+
+        if (args.Port == ent.Comp.OnPort)
+            StartCooking(ent, null);
+    }
+
+    /// <summary>
+    /// Updates the microwave's appearance state.
+    /// </summary>
+    /// <param name="ent">The microwave entity.</param>
+    /// <param name="state">The visual state of the microwave.</param>
+    private void SetAppearance(Entity<MicrowaveComponent> ent,
+        MicrowaveVisualState state)
+    {
+        var display = ent.Comp.Broken ? MicrowaveVisualState.Broken : state;
+        Appearance.SetData(ent.Owner,
+            PowerDeviceVisuals.VisualState,
+            display);
+    }
+}
+
+[Serializable, NetSerializable]
+public enum MicrowaveVisualState
+{
+    Idle,
+    Cooking,
+    Broken,
+    Bloody
+}
+
+[NetSerializable, Serializable]
+public enum MicrowaveUiKey
+{
+    Key
+}
diff --git a/Content.Shared/Kitchen/GetSecretRecipesEvent.cs b/Content.Shared/Kitchen/GetSecretRecipesEvent.cs
index cf5416dfaa..c7d28211be 100644
--- a/Content.Shared/Kitchen/GetSecretRecipesEvent.cs
+++ b/Content.Shared/Kitchen/GetSecretRecipesEvent.cs
@@ -6,5 +6,5 @@ namespace Content.Shared.Kitchen;
 [ByRefEvent]
 public struct GetSecretRecipesEvent()
 {
-    public List<FoodRecipePrototype> Recipes = new();
+    public List<MicrowaveMealRecipePrototype> Recipes = new();
 }
diff --git a/Content.Shared/Kitchen/MicrowaveMealRecipePrototype.cs b/Content.Shared/Kitchen/MicrowaveMealRecipePrototype.cs
index ae8f0e69a4..7104a68078 100644
--- a/Content.Shared/Kitchen/MicrowaveMealRecipePrototype.cs
+++ b/Content.Shared/Kitchen/MicrowaveMealRecipePrototype.cs
@@ -1,63 +1,274 @@
+using System.Linq;
 using Content.Shared.Chemistry.Reagent;
 using Content.Shared.FixedPoint;
+using Content.Shared.Stacks;
 using Robust.Shared.Prototypes;
 
-namespace Content.Shared.Kitchen
+namespace Content.Shared.Kitchen;
+
+/// <summary>
+///    A microwave-based cooking recipe to produce an entity.
+/// </summary>
+[Prototype]
+public sealed partial class MicrowaveMealRecipePrototype : IPrototype
 {
+    /// <inheritdoc />
+    [ViewVariables]
+    [IdDataField]
+    public string ID { get; private set; } = default!;
+
     /// <summary>
-    ///    A recipe for space microwaves.
+    /// The name of the recipe.
     /// </summary>
-    [Prototype("microwaveMealRecipe")]
-    public sealed partial class FoodRecipePrototype : IPrototype
+    /// <remarks>
+    /// This is used to sort recipes in alphabetical order in the guidebook.
+    /// </remarks>
+    [DataField("name")]
+    private LocId _name = string.Empty;
+
+    public string Name => Loc.GetString(_name);
+
+    /// <summary>
+    /// The guidebook grouping for this recipe.
+    /// </summary>
+    [DataField]
+    public string Group = "Other";
+
+    /// <summary>
+    /// The cooking ingredients used in this recipe.
+    /// </summary>
+    [IncludeDataField]
+    public CookingIngredients Ingredients;
+
+    /// <summary>
+    /// The resulting entity made from this recipe.
+    /// </summary>
+    [DataField]
+    public EntProtoId Result { get; private set; } = string.Empty;
+
+    /// <summary>
+    /// The cooking time of this recipe.
+    /// </summary>
+    [DataField]
+    public uint Time { get; private set; } = 5;
+
+    /// <summary>
+    /// Is this recipe unavailable in normal circumstances?
+    /// </summary>
+    [DataField]
+    public bool SecretRecipe;
+
+    /// <summary>
+    /// Manual priority field for recipes that take precedent over others. Higher number = picked over others.
+    /// </summary>
+    /// <remarks>
+    /// Secret recipes always have higher priority over non-secret recipes. Only needed when a recipe's
+    /// ingredients may overlap with another in a way that'll cause that recipe to be chosen over this one
+    /// erroneously. This field should be used as minimally as possible.
+    /// </remarks>
+    [DataField]
+    public int Priority;
+}
+
+/// <summary>
+/// A data value representing ingredients for an appliance recipe.
+/// </summary>
+[DataDefinition]
+public partial record struct CookingIngredients
+{
+    public CookingIngredients(Dictionary<EntProtoId, int> solids,
+        Dictionary<ProtoId<StackPrototype>, int> stacks,
+        Dictionary<ProtoId<ReagentPrototype>, FixedPoint2> reagents)
     {
-        [ViewVariables]
-        [IdDataField]
-        public string ID { get; private set; } = default!;
+        Solids = solids;
+        Stacks = stacks;
+        Reagents = reagents;
+    }
 
-        [DataField("name")]
-        private string _name = string.Empty;
+    /// <summary>
+    /// A dictionary of solid item ingredient quantities - actual items used in a recipe.
+    /// </summary>
+    // TODO: This should use tags or whitelists instead of entity prototype IDs
+    [DataField]
+    public Dictionary<EntProtoId, int> Solids { get; private set; } = new();
 
-        [DataField]
-        public string Group = "Other";
+    /// <summary>
+    /// A dictionary of stack quantities, such as plastic sheets or cloth rolls.
+    /// </summary>
+    [DataField]
+    public Dictionary<ProtoId<StackPrototype>, int> Stacks { get; private set; } = new();
 
-        [DataField("reagents")]
-        private Dictionary<ProtoId<ReagentPrototype>, FixedPoint2> _ingsReagents = new();
+    /// <summary>
+    /// A dictionary of reagent quantities.
+    /// </summary>
+    [DataField]
+    // TODO: Use ReagentQuantity[]
+    public Dictionary<ProtoId<ReagentPrototype>, FixedPoint2> Reagents { get; private set; } = new();
 
-        [DataField("solids")]
-        private Dictionary<EntProtoId, FixedPoint2> _ingsSolids = new();
+    /// <summary>
+    /// Adds a quantity of a solid ingredient to this ingredients list.
+    /// </summary>
+    /// <param name="solidId">The ID of the solid to add.</param>
+    /// <param name="count">How much of the solid to add. 1 by default.</param>
+    public readonly void AddSolid(EntProtoId solidId, int count = 1)
+    {
+        if (count == 0)
+            return;
 
-        [DataField(required: true)]
-        public EntProtoId Result;
+        var newCount = Solids.GetValueOrDefault(solidId) + count;
+        if (newCount > 0)
+            Solids[solidId] = newCount;
+        else
+            Solids.Remove(solidId);
+    }
 
-        [DataField("time")]
-        public uint CookTime { get; private set; } = 5;
+    /// <summary>
+    /// Adds a quantity of a stack to this ingredients list.
+    /// </summary>
+    /// <param name="stackId">The ID of the stack to add.</param>
+    /// <param name="count">How many stacks to add.</param>
+    public readonly void AddStack(ProtoId<StackPrototype> stackId, int count)
+    {
+        if (count == 0)
+            return;
 
-        public string Name => Loc.GetString(_name);
+        var newCount = Stacks.GetValueOrDefault(stackId) + count;
+        if (newCount > 0)
+            Stacks[stackId] = newCount;
+        else
+            Stacks.Remove(stackId);
+    }
 
-        // TODO Turn this into a ReagentQuantity[]
-        public IReadOnlyDictionary<ProtoId<ReagentPrototype>, FixedPoint2> IngredientsReagents => _ingsReagents;
-        public IReadOnlyDictionary<EntProtoId, FixedPoint2> IngredientsSolids => _ingsSolids;
+    /// <summary>
+    /// Adds a quantity of a reagent to this ingredients list.
+    /// </summary>
+    /// <param name="reagentId">The ID of the reagent to add.</param>
+    /// <param name="quantity">The volume of the reagent to add.</param>
+    public readonly void AddReagent(ProtoId<ReagentPrototype> reagentId, FixedPoint2 quantity)
+    {
+        if (quantity == 0)
+            return;
 
-        /// <summary>
-        /// Is this recipe unavailable in normal circumstances?
-        /// </summary>
-        [DataField]
-        public bool SecretRecipe = false;
+        var newQuantity = Reagents.GetValueOrDefault(reagentId) + quantity;
+        if (newQuantity > 0)
+            Reagents[reagentId] = newQuantity;
+        else
+            Reagents.Remove(reagentId);
+    }
 
-        /// <summary>
-        ///    Count the number of ingredients in a recipe for sorting the recipe list.
-        ///    This makes sure that where ingredient lists overlap, the more complex
-        ///    recipe is picked first.
-        /// </summary>
-        public FixedPoint2 IngredientCount()
+    /// <summary>
+    ///    Count the number of ingredients in a recipe for sorting the recipe list.
+    ///    This makes sure that where ingredient lists overlap, the more complex
+    ///    recipe is picked first.
+    /// </summary>
+    public readonly FixedPoint2 Count()
+    {
+        var solidCount = Solids.Sum(s => s.Value);
+        var reagentCount = Reagents.Count;
+        var stackCount = Stacks.Sum(s => s.Value);
+
+        return solidCount + reagentCount + stackCount;
+    }
+
+    /// <summary>
+    /// Get the number of times a given recipe can be made with this struct's ingredients.
+    /// </summary>
+    /// <param name="recipe">The recipe to attempt to make with these ingredients.</param>
+    /// <returns>How many times the given recipe can be made.</returns>
+    public readonly uint PortionForRecipe(CookingIngredients recipe)
+    {
+        var solidPortions = GetTimesFulfilled(Solids, recipe.Solids,
+            (available, count) => (uint)(available / count));
+        if (solidPortions == 0)
+            return 0;
+
+        var stackPortions = GetTimesFulfilled(Stacks, recipe.Stacks,
+            (available, count) => (uint)(available / count));
+        if (stackPortions == 0)
+            return 0;
+
+        var reagentPortions = GetTimesFulfilled(Reagents, recipe.Reagents,
+            (available, count) => (uint)(available / count).Int());
+        if (reagentPortions == 0)
+            return 0;
+
+        return new[] { solidPortions, stackPortions, reagentPortions }.Min();
+    }
+
+    /// <summary>
+    /// Given an ingredient dictionary, and a recipe's ingredient dictionary, gets the maximum
+    /// amount of times the recipe can be fulfilled with our available ingredients.
+    /// </summary>
+    /// <typeparam name="T">The key of the ingredient dictionary.</typeparam>
+    /// <typeparam name="TCount">A numerical quantity of the ingredient in the dictionary.</typeparam>
+    /// <param name="ingredients">A dictionary of available ingredients.</param>
+    /// <param name="recipe">A recipe's dictionary of required ingredients.</param>
+    /// <param name="divide">Function to divide the recipe's ingredient count by our ingredient count.</param>
+    /// <returns>How many times the given recipe's ingredients can be fulfilled.</returns>
+    private static uint GetTimesFulfilled<T, TCount>(Dictionary<T, TCount> ingredients,
+        Dictionary<T, TCount> recipe,
+        Func<TCount, TCount, uint> divide)
+        where T : notnull
+    {
+        var portions = uint.MaxValue;
+
+        foreach (var (ingredient, count) in recipe)
         {
-            FixedPoint2 n = 0;
-            n += _ingsReagents.Count; // number of distinct reagents
-            foreach (FixedPoint2 i in _ingsSolids.Values) // sum the number of solid ingredients
-            {
-                n += i;
-            }
-            return n;
+            if (!ingredients.TryGetValue(ingredient, out var available))
+                return 0;
+
+            var ingredientPortions = divide(available, count);
+            portions = Math.Min(portions, ingredientPortions);
         }
+
+        return portions;
+    }
+
+    /// <summary>
+    /// Sum the ingredient counts of two ingredient structs and return the result.
+    /// </summary>
+    public static CookingIngredients operator +(CookingIngredients c1, CookingIngredients c2)
+    {
+        var newIngredients = c1;
+
+        foreach (var (key, count) in c2.Solids)
+        {
+            newIngredients.AddSolid(key, count);
+        }
+
+        foreach (var (key, count) in c2.Stacks)
+        {
+            newIngredients.AddStack(key, count);
+        }
+
+        foreach (var (key, quantity) in c2.Reagents)
+        {
+            newIngredients.AddReagent(key, quantity);
+        }
+
+        return newIngredients;
+    }
+
+    /// <summary>
+    /// Multiply the amount of ingredients by a scalar and return the result.
+    /// </summary>
+    public static CookingIngredients operator *(CookingIngredients c1, int scalar)
+    {
+        var scaledSolids = c1.Solids.ToDictionary(kvp => kvp.Key,
+            kvp => kvp.Value * scalar);
+        var scaledStacks = c1.Stacks.ToDictionary(kvp => kvp.Key,
+            kvp => kvp.Value * scalar);
+        var scaledReagents = c1.Reagents.ToDictionary(kvp => kvp.Key,
+            kvp => kvp.Value * scalar);
+
+        return new(scaledSolids, scaledStacks, scaledReagents);
+    }
+
+    /// <summary>
+    /// Multiply the amount of ingredients by a scalar and return the result.
+    /// </summary>
+    public static CookingIngredients operator *(CookingIngredients c1, uint scalar)
+    {
+        return c1 * (int)scalar;
     }
 }
diff --git a/Content.Shared/Kitchen/RecipeManager.cs b/Content.Shared/Kitchen/RecipeManager.cs
deleted file mode 100644
index ac549ee74a..0000000000
--- a/Content.Shared/Kitchen/RecipeManager.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using System.Linq;
-using Robust.Shared.Prototypes;
-
-namespace Content.Shared.Kitchen;
-
-public sealed partial class RecipeManager : EntitySystem
-{
-    public List<FoodRecipePrototype> Recipes { get; private set; } = new();
-
-    public override void Initialize()
-    {
-        base.Initialize();
-
-        ReloadRecipes();
-        SubscribeLocalEvent<PrototypesReloadedEventArgs>(OnPrototypesReloaded);
-    }
-
-    private void OnPrototypesReloaded(PrototypesReloadedEventArgs args)
-    {
-        if (args.WasModified<FoodRecipePrototype>())
-            ReloadRecipes();
-    }
-
-    private void ReloadRecipes()
-    {
-        Recipes = ProtoMan
-            .EnumeratePrototypes<FoodRecipePrototype>()
-            .Where(x => !x.SecretRecipe)
-            .OrderByDescending(x => x.IngredientCount())
-            .ToList();
-    }
-}
diff --git a/Content.Shared/Kitchen/RecipeSystem.cs b/Content.Shared/Kitchen/RecipeSystem.cs
new file mode 100644
index 0000000000..ab56e964ac
--- /dev/null
+++ b/Content.Shared/Kitchen/RecipeSystem.cs
@@ -0,0 +1,45 @@
+using System.Linq;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Kitchen;
+
+/// <summary>
+/// A system that caches all available non-secret microwave recipes.
+/// </summary>
+public sealed partial class RecipeSystem : EntitySystem
+{
+    /// <summary>
+    /// A list of all recipes available to the recipe manager.
+    /// </summary>
+    /// <remarks>
+    /// Order matters! The microwave system will use the *first* valid recipe.
+    /// For this reason, this list gets sorted by "complexity" - recipes with more ingredients
+    /// are sorted first. We make the assumption that more complex recipes are more "specific"
+    /// than less complex recipes whose requirements are also fulfilled.
+    /// </remarks>
+    public List<MicrowaveMealRecipePrototype> Recipes { get; private set; } = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        ReloadRecipes();
+        SubscribeLocalEvent<PrototypesReloadedEventArgs>(OnPrototypesReloaded);
+    }
+
+    private void OnPrototypesReloaded(PrototypesReloadedEventArgs args)
+    {
+        if (args.WasModified<MicrowaveMealRecipePrototype>())
+            ReloadRecipes();
+    }
+
+    private void ReloadRecipes()
+    {
+        Recipes = ProtoMan
+            .EnumeratePrototypes<MicrowaveMealRecipePrototype>()
+            .Where(x => !x.SecretRecipe)
+            .OrderByDescending(x => x.Priority)
+            .ThenByDescending(x => x.Ingredients.Count())
+            .ToList();
+    }
+}
diff --git a/Resources/Locale/en-US/guidebook/cooking.ftl b/Resources/Locale/en-US/guidebook/cooking.ftl
index 14b95253b3..e3a6a44091 100644
--- a/Resources/Locale/en-US/guidebook/cooking.ftl
+++ b/Resources/Locale/en-US/guidebook/cooking.ftl
@@ -13,3 +13,6 @@ guidebook-microwave-reagent-quantity-display = × {$amount}u
 
 guidebook-microwave-solid-name-display = [bold]{$ingredient}[/bold]
 guidebook-microwave-solid-quantity-display = × {$amount}
+
+guidebook-microwave-stack-name-display = [bold]{$stack}[/bold]
+guidebook-microwave-stack-quantity-display = × {$amount}
diff --git a/Resources/Locale/en-US/kitchen/prototypes/microwave-meal-recipe-prototype.ftl b/Resources/Locale/en-US/kitchen/prototypes/microwave-meal-recipe-prototype.ftl
new file mode 100644
index 0000000000..ba41e33452
--- /dev/null
+++ b/Resources/Locale/en-US/kitchen/prototypes/microwave-meal-recipe-prototype.ftl
@@ -0,0 +1,221 @@
+microwave-meal-recipe-bun-name = bun recipe
+microwave-meal-recipe-cotton-bun-name = cotton bun recipe
+microwave-meal-recipe-bagel-name = bagel recipe
+microwave-meal-recipe-bagel-poppy-name = poppyseed bagel recipe
+microwave-meal-recipe-bagel-cotton-name = cotton bagel recipe
+microwave-meal-recipe-appendix-burger-name = appendix burger recipe
+microwave-meal-recipe-bacon-burger-name = bacon burger recipe
+microwave-meal-recipe-baseball-burger-name = baseball burger recipe
+microwave-meal-recipe-bearger-name = bearger recipe
+microwave-meal-recipe-big-bite-burger-name = big bite burger recipe
+microwave-meal-recipe-brain-burger-name = brain burger recipe
+microwave-meal-recipe-cat-burger-name = cat burger recipe
+microwave-meal-recipe-cheeseburger-name = cheeseburger recipe
+microwave-meal-recipe-chicken-sandiwch-name = chicken sandwich recipe
+microwave-meal-recipe-clown-burger-name = clownburger recipe
+microwave-meal-recipe-corgi-burger-name = corgi burger recipe
+microwave-meal-recipe-crab-burger-name = crab burger recipe
+microwave-meal-recipe-crazy-hamburger-name = crazy hamburger recipe
+microwave-meal-recipe-duck-burger-name = duck sandwich recipe
+microwave-meal-recipe-empowered-burger-name = empowered burger recipe
+microwave-meal-recipe-carp-burger-name = fillet-o-carp burger recipe
+microwave-meal-recipe-five-burger-name = five alarm burger recipe
+microwave-meal-recipe-ghost-burger-name = ghost burger recipe
+microwave-meal-recipe-human-burger-name = human burger recipe
+microwave-meal-recipe-jelly-burger-name = jelly burger recipe
+microwave-meal-recipe-burger-mcguffin-name = McGuffin recipe
+microwave-meal-recipe-burger-mcrib-name = BBQ rib sandwich recipe
+microwave-meal-recipe-mime-burger-name = mime burger recipe
+microwave-meal-recipe-plain-burger-name = plain burger recipe
+microwave-meal-recipe-rat-burger-name = rat burger recipe
+microwave-meal-recipe-robot-burger-name = roburger recipe
+microwave-meal-recipe-soylent-burger-name = soylent burger recipe
+microwave-meal-recipe-spell-burger-name = spell burger recipe
+microwave-meal-recipe-super-bite-burger-name = super bite burger recipe
+microwave-meal-recipe-tofu-burger-name = tofu burger recipe
+microwave-meal-recipe-xenoburger-name = xenoburger recipe
+microwave-meal-recipe-moth-roachburger-name = mothroachburger recipe
+microwave-meal-recipe-banana-bread-name = banana bread recipe
+microwave-meal-recipe-cornbread-name = cornbread recipe
+microwave-meal-recipe-cream-cheese-bread-name = cream cheese bread recipe
+microwave-meal-recipe-meat-bread-name = meat bread recipe
+microwave-meal-recipe-mimana-bread-name = mimana bread recipe
+microwave-meal-recipe-bread-name = bread recipe
+microwave-meal-recipe-bread-cotton-name = cotton bread recipe
+microwave-meal-recipe-sausage-bread-name = sausage bread recipe
+microwave-meal-recipe-spider-meat-bread-name = spider meat bread recipe
+microwave-meal-recipe-tofu-bread-name = tofu bread recipe
+microwave-meal-recipe-xeno-meat-bread-name = xeno meat bread recipe
+microwave-meal-recipe-baguette-name = baguette recipe
+microwave-meal-recipe-baguette-cotton-name = baguette recipe
+microwave-meal-recipe-baguette-sword-name = baguette sword recipe
+microwave-meal-recipe-buttered-toast-name = buttered toast recipe
+microwave-meal-recipe-french-toast-name = french toast recipe
+microwave-meal-recipe-garlic-bread-name = garlic bread slice recipe
+microwave-meal-recipe-jelly-toast-name = jelly toast recipe
+microwave-meal-recipe-moldy-bread-slice-name = moldy bread slice recipe
+microwave-meal-recipe-two-bread-slice-name = two slice recipe
+microwave-meal-recipe-onion-rings-name = onion rings recipe
+microwave-meal-recipe-margherita-pizza-name = margherita pizza recipe
+microwave-meal-recipe-mushroom-pizza-name = mushroom pizza recipe
+microwave-meal-recipe-meat-pizza-name = meat pizza recipe
+microwave-meal-recipe-vegetable-pizza-name = vegetable pizza recipe
+microwave-meal-recipe-hawaiian-pizza-name = Hawaiian pizza recipe
+microwave-meal-recipe-dank-pizza-name = dank pizza recipe
+microwave-meal-recipe-donkpocket-pizza-name = donk-pocket pizza recipe
+microwave-meal-recipe-uranium-pizza-name = spicy rock pizza recipe
+microwave-meal-recipe-cotton-pizza-name = cotton pizza recipe
+microwave-meal-recipe-worldpeas-pizza-name = world peazza recipe
+microwave-meal-recipe-boiled-spaghetti-name = boiled spaghetti recipe
+microwave-meal-recipe-pasta-tomato-name = pasta tomato recipe
+microwave-meal-recipe-meatball-spaghetti-name = spaghetti & meatballs recipe
+microwave-meal-recipe-butter-noodles-name = butter noodles recipe
+microwave-meal-recipe-chow-mein-name = chow mein recipe
+microwave-meal-recipe-oatmeal-name = oatmeal recipe
+microwave-meal-recipe-boiled-rice-name = boiled rice recipe
+microwave-meal-recipe-rice-pudding-name = rice pudding recipe
+microwave-meal-recipe-rice-pork-name = rice and pork recipe
+microwave-meal-recipe-rice-gumbo-name = black-eyed gumbo recipe
+microwave-meal-recipe-egg-rice-name = egg-fried rice recipe
+microwave-meal-recipe-copypasta-name = copypasta recipe
+microwave-meal-recipe-bisque-name = bisque recipe
+microwave-meal-recipe-meatball-soup-name = meatball soup recipe
+microwave-meal-recipe-nettle-soup-name = nettle soup recipe
+microwave-meal-recipe-eyeball-soup-name = eyeball soup recipe
+microwave-meal-recipe-amanita-jelly-name = amanita jelly recipe
+microwave-meal-recipe-onion-soup-name = onion soup recipe
+microwave-meal-recipe-mushroom-soup-name = mushroom soup recipe
+microwave-meal-recipe-stew-soup-name = stew recipe
+microwave-meal-recipe-tomato-soup-name = tomato soup recipe
+microwave-meal-recipe-tomato-blood-soup-name = tomato blood soup recipe
+microwave-meal-recipe-wing-fang-chu-soup-name = wing fang chu recipe
+microwave-meal-recipe-wing-fang-chu-soup-spider-name = wing fang chu recipe
+microwave-meal-recipe-vegetable-soup-name = vegetable soup recipe
+microwave-meal-recipe-clown-tears-soup-name = clown tears soup recipe
+microwave-meal-recipe-monkeys-delight-soup-name = monkeys delight recipe
+microwave-meal-recipe-bungo-soup-name = bungo soup recipe
+microwave-meal-recipe-boiled-snail-name = boiled snail recipe
+microwave-meal-recipe-escargot-soup-name = escargot recipe
+microwave-meal-recipe-amanita-pie-name = amanita pie recipe
+microwave-meal-recipe-apple-pie-name = apple pie recipe
+microwave-meal-recipe-baklava-name = baklava recipe
+microwave-meal-recipe-banana-cream-pie-name = banana cream pie recipe
+microwave-meal-recipe-berry-clafoutis-name = berry clafoutis recipe
+microwave-meal-recipe-cherry-pie-name = cherry pie recipe
+microwave-meal-recipe-frosty-pie-name = frosty pie recipe
+microwave-meal-recipe-meat-pie-name = meat pie recipe
+microwave-meal-recipe-pumpkin-pie-name = pumpkin pie recipe
+microwave-meal-recipe-xeno-pie-name = xeno pie recipe
+microwave-meal-recipe-coco-tart-name = chocolate lava tart recipe
+microwave-meal-recipe-gapple-tart-name = golden apple streusel tart recipe
+microwave-meal-recipe-grape-tart-name = grape tart recipe
+microwave-meal-recipe-mime-tart-name = mime tart recipe
+microwave-meal-recipe-cuban-carp-name = Cuban carp recipe
+microwave-meal-recipe-sashimi-name = sashimi recipe
+microwave-meal-recipe-miso-cola-soup-name = salty sweet misocola soup recipe
+microwave-meal-recipe-loaded-baked-potato-name = loaded baked potato recipe
+microwave-meal-recipe-fries-name = space fries recipe
+microwave-meal-recipe-cheesy-fries-name = cheesy fries recipe
+microwave-meal-recipe-carrot-fries-name = carrot fries recipe
+microwave-meal-recipe-nachos-name = nachos recipe
+microwave-meal-recipe-nachos-cheesy-name = cheesy nachos recipe
+microwave-meal-recipe-nachos-cuban-name = cuban nachos recipe
+microwave-meal-recipe-popcorn-name = popcorn recipe
+microwave-meal-recipe-pancake-name = pancake recipe
+microwave-meal-recipe-blueberry-pancake-name = blueberry pancake recipe
+microwave-meal-recipe-waffles-name = waffle recipe
+microwave-meal-recipe-waffle-soy-name = soy waffle recipe
+microwave-meal-recipe-cookie-name = cookie recipe
+microwave-meal-recipe-sugar-cookie-name = sugar cookie recipe
+microwave-meal-recipe-raisin-cookie-name = raisin cookie recipe
+microwave-meal-recipe-cookie-oatmeal-name = oatmeal cookie recipe
+microwave-meal-recipe-chocolate-chip-pancake-name = chocolate chip pancake recipe
+microwave-meal-recipe-apple-cake-name = apple cake recipe
+microwave-meal-recipe-carrot-cake-name = carrot cake recipe
+microwave-meal-recipe-lemon-cake-name = lemon cake recipe
+microwave-meal-recipe-lemoon-cake-name = lemoon cake recipe
+microwave-meal-recipe-orange-cake-name = orange cake recipe
+microwave-meal-recipe-blueberry-cake-name = blueberry cake recipe
+microwave-meal-recipe-lime-cake-name = lime cake recipe
+microwave-meal-recipe-cheese-cake-name = cheese cake recipe
+microwave-meal-recipe-pumpkin-cake-name = pumpkin cake recipe
+microwave-meal-recipe-clown-cake-name = clown cake recipe
+microwave-meal-recipe-cake-name = cake recipe
+microwave-meal-recipe-birthday-cake-name = birthday cake recipe
+microwave-meal-recipe-chocolate-cake-name = chocolate cake recipe
+microwave-meal-recipe-brain-cake-name = brain cake recipe
+microwave-meal-recipe-slime-cake-name = slime cake recipe
+microwave-meal-recipe-cat-cake-name = cat cake recipe
+microwave-meal-recipe-berry-delight-name = berry delight recipe
+microwave-meal-recipe-bread-dog-name = bread dog recipe
+microwave-meal-recipe-dumplings-name = dumplings recipe
+microwave-meal-recipe-brownies-name = brownie recipe
+microwave-meal-recipe-warm-donkpocket-name = warm donk pocket recipe
+microwave-meal-recipe-warm-dankpocket-name = warm dank pocket recipe
+microwave-meal-recipe-warm-donkpocket-spicy-name = warm spicy donk-pocket recipe
+microwave-meal-recipe-warm-donkpocket-teriyaki-name = warm teriyaki-pocket recipe
+microwave-meal-recipe-warm-donkpocket-pizza-name = warm pizza-pocket recipe
+microwave-meal-recipe-donkpocket-honk-name = warm honk-pocket recipe
+microwave-meal-recipe-donkpocket-berry-name = warm berry-pocket recipe
+microwave-meal-recipe-donkpocket-stonk-name = warm stonk-pocket recipe
+microwave-meal-recipe-donkpocket-carp-name = warm carp-pocket recipe
+microwave-meal-recipe-donkpocket-moth-name = warm moth-pocket recipe
+microwave-meal-recipe-hot-chili-name = hot chili recipe
+microwave-meal-recipe-cold-chili-name = cold chili recipe
+microwave-meal-recipe-clown-tears-name = clown's tears recipe
+microwave-meal-recipe-chili-clown-name = chili con carnival recipe
+microwave-meal-recipe-queso-name = queso recipe
+microwave-meal-recipe-ribs-name = BBQ ribs recipe
+microwave-meal-recipe-enchiladas-name = enchiladas recipe
+microwave-meal-recipe-herb-salad-name = herb salad recipe
+microwave-meal-recipe-valid-salad-name = valid salad recipe
+microwave-meal-recipe-coleslaw-name = coleslaw recipe
+microwave-meal-recipe-caesar-salad-name = caesar salad recipe
+microwave-meal-recipe-citrus-salad-name = citrus salad recipe
+microwave-meal-recipe-kimchi-salad-name = kimchi salad recipe
+microwave-meal-recipe-fruit-salad-name = fruit salad recipe
+microwave-meal-recipe-jungle-salad-name = jungle salad recipe
+microwave-meal-recipe-watermelon-fruit-bowl-salad-name = watermelon fruit bowl recipe
+microwave-meal-recipe-muffin-name = muffin recipe
+microwave-meal-recipe-muffin-chocolate-name = chocolate muffin recipe
+microwave-meal-recipe-muffin-berry-name = berry muffin recipe
+microwave-meal-recipe-muffin-banana-name = banana muffin recipe
+microwave-meal-recipe-muffin-cherry-name = cherry muffin recipe
+microwave-meal-recipe-dried-tea-leaves-name = dried tea leaves recipe
+microwave-meal-recipe-dried-tobacco-name = dried tobacco leaves recipe
+microwave-meal-recipe-dried-cannabis-name = dried cannabis leaves recipe
+microwave-meal-recipe-dried-cannabis-rainbow-name = dried rainbow cannabis leaves recipe
+microwave-meal-recipe-trash-baked-banana-peel-name = baked banana peel recipe
+microwave-meal-recipe-suppermatter-name = suppermatter recipe
+microwave-meal-recipe-food-baked-chevre-chaud-name = chevre chaud recipe
+microwave-meal-recipe-food-baked-chevre-chaud-cotton-name = cotton chevre chaud recipe
+microwave-meal-recipe-cannabis-butter-name = cannabis butter recipe
+microwave-meal-recipe-cannabis-brownies-name = cannabis brownie recipe
+microwave-meal-recipe-corn-in-butter-name = corn in butter recipe
+microwave-meal-recipe-pea-soup-name = pea soup recipe
+microwave-meal-recipe-taco-shell-name = taco shell recipe
+microwave-meal-recipe-taco-beef-name = beef taco recipe
+microwave-meal-recipe-taco-chicken-name = chicken taco recipe
+microwave-meal-recipe-taco-fish-name = fish taco recipe
+microwave-meal-recipe-taco-rat-name = rat taco recipe
+microwave-meal-recipe-taco-beef-supreme-name = beef taco supreme recipe
+microwave-meal-recipe-taco-chicken-supreme-name = beef taco supreme recipe
+microwave-meal-recipe-taco-dragon-name = draco recipe
+microwave-meal-recipe-croissant-name = croissant recipe
+microwave-meal-recipe-croissant-cotton-name = cotton croissant recipe
+microwave-meal-recipe-throwing-croissant-name = throwing croissant recipe
+microwave-meal-recipe-inert-anomaly-meat-name = inert meat anomaly recipe
+microwave-meal-recipe-anomaly-meat-name = meat anomaly recipe
+microwave-meal-recipe-anomaly-meat-cooked-name = cooked meat anomaly recipe
+microwave-meal-recipe-grilled-cheese-sandwich-name = grilled cheese sandwich recipe
+microwave-meal-recipe-grilled-cheese-sandwich-cotton-name = cotton grilled cheese sandwich recipe
+microwave-meal-recipe-breakfast-american-name = full american breakfast recipe
+microwave-meal-recipe-breakfast-english-name = full english breakfast recipe
+microwave-meal-recipe-moproach-name = moproach recipe
+microwave-meal-recipe-cotton-cake-name = cotton cake recipe
+
+# medical recipes
+
+microwave-meal-recipe-aloe-cream-name = aloe cream recipe
+microwave-meal-recipe-medicated-suture-name = medicated suture recipe
+microwave-meal-recipe-regenerative-mesh-name = regenerative mesh recipe
diff --git a/Resources/Prototypes/Entities/Structures/Machines/microwave.yml b/Resources/Prototypes/Entities/Structures/Machines/microwave.yml
index 8a0c2909d8..6bcf13a955 100644
--- a/Resources/Prototypes/Entities/Structures/Machines/microwave.yml
+++ b/Resources/Prototypes/Entities/Structures/Machines/microwave.yml
@@ -160,7 +160,7 @@
   components:
   - type: Microwave
     cookTimeMultiplier: 0.5
-    baseHeatMultiplier: 200
+    objectHeatMultiplier: 200
     capacity: 10
     canMicrowaveIdsSafely: false
     explosionChance: 0.3
diff --git a/Resources/Prototypes/Recipes/Cooking/meal_recipes.yml b/Resources/Prototypes/Recipes/Cooking/meal_recipes.yml
index b41403a9f0..44fce9ede6 100644
--- a/Resources/Prototypes/Recipes/Cooking/meal_recipes.yml
+++ b/Resources/Prototypes/Recipes/Cooking/meal_recipes.yml
@@ -1,6 +1,6 @@
 - type: microwaveMealRecipe
   id: RecipeBun
-  name: bun recipe
+  name: microwave-meal-recipe-bun-name
   result: FoodBreadBun
   time: 5
   group: Breads
@@ -9,7 +9,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCottonBun
-  name: cotton bun recipe
+  name: microwave-meal-recipe-cotton-bun-name
   result: FoodCottonBun
   time: 5
   group: Moth
@@ -19,7 +19,7 @@
 #Bagels
 - type: microwaveMealRecipe
   id: RecipeBagel
-  name: bagel recipe
+  name: microwave-meal-recipe-bagel-name
   result: FoodBagel
   time: 5
   group: Breads
@@ -28,7 +28,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBagelPoppy
-  name: poppyseed bagel recipe
+  name: microwave-meal-recipe-bagel-poppy-name
   result: FoodBagelPoppy
   time: 5
   group: Breads
@@ -38,7 +38,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBagelCotton
-  name: cotton bagel recipe
+  name: microwave-meal-recipe-bagel-cotton-name
   result: FoodBagelCotton
   time: 5
   group: Moth
@@ -49,7 +49,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeAppendixBurger
-  name: appendix burger recipe
+  name: microwave-meal-recipe-appendix-burger-name
   result: FoodBurgerAppendix
   time: 10
   group: Savory
@@ -59,7 +59,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBaconBurger
-  name: bacon burger recipe
+  name: microwave-meal-recipe-bacon-burger-name
   result: FoodBurgerBacon
   time: 10
   group: Savory
@@ -70,7 +70,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBaseballBurger
-  name: baseball burger recipe
+  name: microwave-meal-recipe-baseball-burger-name
   result: FoodBurgerBaseball
   time: 10
   group: Savory
@@ -80,7 +80,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBearger
-  name: bearger recipe
+  name: microwave-meal-recipe-bearger-name
   result: FoodBurgerBear
   time: 10
   group: Savory
@@ -90,7 +90,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBigBiteBurger
-  name: big bite burger recipe
+  name: microwave-meal-recipe-big-bite-burger-name
   result: FoodBurgerBig
   time: 15
   group: Savory
@@ -103,7 +103,7 @@
 
 - type: microwaveMealRecipe #Added to metamorph recipes
   id: RecipeBrainBurger
-  name: brain burger recipe
+  name: microwave-meal-recipe-brain-burger-name
   result: FoodBurgerBrain
   time: 10
   group: Savory
@@ -113,7 +113,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCatBurger
-  name: cat burger recipe
+  name: microwave-meal-recipe-cat-burger-name
   result: FoodBurgerCat
   time: 10
   group: Savory
@@ -124,7 +124,7 @@
 
 - type: microwaveMealRecipe #Added to metamorph recipes
   id: RecipeCheeseburger
-  name: cheeseburger recipe
+  name: microwave-meal-recipe-cheeseburger-name
   result: FoodBurgerCheese
   time: 10
   group: Savory
@@ -135,7 +135,7 @@
 
 - type: microwaveMealRecipe #Added to metamorph recipes
   id: RecipeChickenSandwich
-  name: chicken sandwich recipe
+  name: microwave-meal-recipe-chicken-sandiwch-name
   result: FoodBurgerChicken
   time: 10
   group: Savory
@@ -147,7 +147,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeClownBurger
-  name: clownburger recipe
+  name: microwave-meal-recipe-clown-burger-name
   result: FoodBurgerClown
   time: 10
   group: Savory
@@ -157,7 +157,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCorgiBurger
-  name: corgi burger recipe
+  name: microwave-meal-recipe-corgi-burger-name
   result: FoodBurgerCorgi
   time: 10
   group: Savory
@@ -167,7 +167,7 @@
 
 - type: microwaveMealRecipe #Added to metamorph recipes
   id: RecipeCrabBurger
-  name: crab burger recipe
+  name: microwave-meal-recipe-crab-burger-name
   result: FoodBurgerCrab
   time: 10
   group: Savory
@@ -177,7 +177,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCrazyHamburger
-  name: crazy hamburger recipe
+  name: microwave-meal-recipe-crazy-hamburger-name
   result: FoodBurgerCrazy
   time: 15
   group: Savory
@@ -194,7 +194,7 @@
 
 - type: microwaveMealRecipe #Added to metamorph recipes
   id: RecipeDuckBurger
-  name: duck sandwich recipe
+  name: microwave-meal-recipe-duck-burger-name
   result: FoodBurgerDuck
   time: 10
   group: Savory
@@ -205,17 +205,18 @@
 
 - type: microwaveMealRecipe
   id: RecipeEmpoweredBurger
-  name: empowered burger recipe
+  name: microwave-meal-recipe-empowered-burger-name
   result: FoodBurgerEmpowered
   time: 10
   group: Savory
   solids:
     FoodBreadBun: 1
-    SheetPlasma1: 2
+  stacks:
+    Plasma: 2
 
 - type: microwaveMealRecipe
   id: RecipeCarpBurger
-  name: fillet-o-carp burger recipe
+  name: microwave-meal-recipe-carp-burger-name
   result: FoodBurgerCarp
   time: 10
   group: Savory
@@ -226,7 +227,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeFiveBurger
-  name: five alarm burger recipe
+  name: microwave-meal-recipe-five-burger-name
   result: FoodBurgerFive
   time: 10
   group: Savory
@@ -237,7 +238,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeGhostBurger
-  name: ghost burger recipe
+  name: microwave-meal-recipe-ghost-burger-name
   result: FoodBurgerGhost
   time: 10
   group: Savory
@@ -247,7 +248,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeHumanBurger
-  name: human burger recipe
+  name: microwave-meal-recipe-human-burger-name
   result: FoodBurgerHuman
   time: 10
   group: Savory
@@ -257,7 +258,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeJellyBurger
-  name: jelly burger recipe
+  name: microwave-meal-recipe-jelly-burger-name
   result: FoodBurgerJelly
   time: 10
   group: Savory
@@ -267,7 +268,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBurgerMcguffin
-  name: McGuffin recipe
+  name: microwave-meal-recipe-burger-mcguffin-name
   result: FoodBurgerMcguffin
   time: 10
   group: Savory
@@ -279,7 +280,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBurgerMcrib
-  name: BBQ rib sandwich recipe
+  name: microwave-meal-recipe-burger-mcrib-name
   result: FoodBurgerMcrib
   time: 10
   group: Savory
@@ -290,7 +291,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMimeBurger
-  name: mime burger recipe
+  name: microwave-meal-recipe-mime-burger-name
   result: FoodBurgerMime
   time: 10
   group: Savory
@@ -300,7 +301,7 @@
 
 - type: microwaveMealRecipe
   id: RecipePlainBurger
-  name: plain burger recipe
+  name: microwave-meal-recipe-plain-burger-name
   result: FoodBurgerPlain
   time: 10
   group: Savory
@@ -310,7 +311,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeRatBurger
-  name: rat burger recipe
+  name: microwave-meal-recipe-rat-burger-name
   result: FoodBurgerRat
   time: 10
   group: Savory
@@ -320,7 +321,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeRobotBurger
-  name: roburger recipe
+  name: microwave-meal-recipe-robot-burger-name
   result: FoodBurgerRobot
   time: 10
   group: Savory
@@ -331,7 +332,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSoylentBurger
-  name: soylent burger recipe
+  name: microwave-meal-recipe-soylent-burger-name
   result: FoodBurgerSoy
   time: 10
   group: Savory
@@ -342,7 +343,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSpellBurger
-  name: spell burger recipe
+  name: microwave-meal-recipe-spell-burger-name
   result: FoodBurgerSpell
   time: 10
   group: Savory
@@ -352,7 +353,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSuperBiteBurger
-  name: super bite burger recipe
+  name: microwave-meal-recipe-super-bite-burger-name
   result: FoodBurgerSuper
   time: 25
   group: Savory
@@ -368,7 +369,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTofuBurger
-  name: tofu burger recipe
+  name: microwave-meal-recipe-tofu-burger-name
   result: FoodBurgerTofu
   time: 10
   group: Savory
@@ -378,7 +379,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeXenoburger
-  name: xenoburger recipe
+  name: microwave-meal-recipe-xenoburger-name
   result: FoodBurgerXeno
   time: 10
   group: Savory
@@ -388,7 +389,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMothRoachburger
-  name: mothroachburger recipe
+  name: microwave-meal-recipe-moth-roachburger-name
   result: FoodBurgerMothRoach
   group: Savory
   solids:
@@ -399,7 +400,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBananaBread
-  name: banana bread recipe
+  name: microwave-meal-recipe-banana-bread-name
   result: FoodBreadBanana
   time: 15
   group: Breads
@@ -409,7 +410,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCornbread
-  name: cornbread recipe
+  name: microwave-meal-recipe-cornbread-name
   result: FoodBreadCorn
   time: 10
   group: Breads
@@ -418,7 +419,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCreamCheeseBread
-  name: cream cheese bread recipe
+  name: microwave-meal-recipe-cream-cheese-bread-name
   result: FoodBreadCreamcheese
   time: 15
   group: Breads
@@ -430,7 +431,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMeatBread
-  name: meat bread recipe
+  name: microwave-meal-recipe-meat-bread-name
   result: FoodBreadMeat
   time: 15
   group: Breads
@@ -441,7 +442,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMimanaBread
-  name: mimana bread recipe
+  name: microwave-meal-recipe-mimana-bread-name
   result: FoodBreadMimana
   time: 15
   group: Breads
@@ -453,7 +454,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBread
-  name: bread recipe
+  name: microwave-meal-recipe-bread-name
   result: FoodBreadPlain
   time: 10
   group: Breads
@@ -462,7 +463,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBreadCotton
-  name: cotton bread recipe
+  name: microwave-meal-recipe-bread-cotton-name
   result: FoodBreadCotton
   time: 10
   group: Moth
@@ -471,7 +472,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSausageBread
-  name: sausage bread recipe
+  name: microwave-meal-recipe-sausage-bread-name
   result: FoodBreadSausage
   time: 15
   group: Breads
@@ -481,7 +482,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSpiderMeatBread
-  name: spider meat bread recipe
+  name: microwave-meal-recipe-spider-meat-bread-name
   result: FoodBreadMeatSpider
   time: 15
   group: Breads
@@ -492,7 +493,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTofuBread
-  name: tofu bread recipe
+  name: microwave-meal-recipe-tofu-bread-name
   result: FoodBreadTofu
   time: 15
   group: Breads
@@ -502,7 +503,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeXenoMeatBread
-  name: xeno meat bread recipe
+  name: microwave-meal-recipe-xeno-meat-bread-name
   result: FoodBreadMeatXeno
   time: 15
   group: Breads
@@ -515,7 +516,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBaguette
-  name: baguette recipe
+  name: microwave-meal-recipe-baguette-name
   result: FoodBreadBaguette
   time: 15
   group: Breads
@@ -527,7 +528,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBaguetteCotton
-  name: baguette recipe
+  name: microwave-meal-recipe-baguette-cotton-name
   result: FoodBreadBaguetteCotton
   time: 15
   group: Moth
@@ -539,7 +540,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBaguetteSword
-  name: baguette sword recipe
+  name: microwave-meal-recipe-baguette-sword-name
   result: WeaponBaguette
   secretRecipe: true
   time: 15
@@ -547,13 +548,14 @@
   reagents:
     TableSalt: 1
     Blackpepper: 1
+  stacks:
+    MetalRod: 1
   solids:
     FoodDough: 1
-    PartRodMetal1: 1
 
 - type: microwaveMealRecipe
   id: RecipeButteredToast
-  name: buttered toast recipe
+  name: microwave-meal-recipe-buttered-toast-name
   result: FoodBreadButteredToast
   time: 5
   group: Breads
@@ -563,7 +565,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeFrenchToast
-  name: french toast recipe
+  name: microwave-meal-recipe-french-toast-name
   result: FoodBreadFrenchToast
   time: 5
   group: Breakfast
@@ -575,7 +577,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeGarlicBread
-  name: garlic bread slice recipe
+  name: microwave-meal-recipe-garlic-bread-name
   result: FoodBreadGarlicSlice
   time: 5
   group: Breads
@@ -586,7 +588,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeJellyToast
-  name: jelly toast recipe
+  name: microwave-meal-recipe-jelly-toast-name
   result: FoodBreadJellySlice
   time: 5
   group: Breads
@@ -596,7 +598,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMoldyBreadSlice
-  name: moldy bread slice recipe
+  name: microwave-meal-recipe-moldy-bread-slice-name
   result: FoodBreadMoldySlice
   time: 5
   group: Breads
@@ -606,7 +608,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTwoBreadSlice
-  name: two slice recipe
+  name: microwave-meal-recipe-two-bread-slice-name
   result: FoodBreadTwoSlice
   time: 5
   group: Breads
@@ -617,7 +619,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeOnionRings
-  name: onion rings recipe
+  name: microwave-meal-recipe-onion-rings-name
   result: FoodOnionRings
   time: 15
   group: Savory
@@ -627,7 +629,7 @@
 #Pizzas TODO: contruction graph based pizza
 - type: microwaveMealRecipe
   id: RecipeMargheritaPizza
-  name: margherita pizza recipe
+  name: microwave-meal-recipe-margherita-pizza-name
   result: FoodPizzaMargherita
   time: 30
   group: Pizza
@@ -638,7 +640,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMushroomPizza
-  name: mushroom pizza recipe
+  name: microwave-meal-recipe-mushroom-pizza-name
   result: FoodPizzaMushroom
   time: 30
   group: Pizza
@@ -648,7 +650,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMeatPizza
-  name: meat pizza recipe
+  name: microwave-meal-recipe-meat-pizza-name
   result: FoodPizzaMeat
   time: 30
   group: Pizza
@@ -660,7 +662,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeVegetablePizza
-  name: vegetable pizza recipe
+  name: microwave-meal-recipe-vegetable-pizza-name
   result: FoodPizzaVegetable
   time: 30
   group: Pizza
@@ -673,7 +675,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeHawaiianPizza
-  name: Hawaiian pizza recipe
+  name: microwave-meal-recipe-hawaiian-pizza-name
   result: FoodPizzaPineapple
   time: 30
   group: Pizza
@@ -684,7 +686,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDankPizza
-  name: dank pizza recipe
+  name: microwave-meal-recipe-dank-pizza-name
   result: FoodPizzaDank
   time: 30
   group: Pizza
@@ -696,7 +698,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDonkpocketPizza
-  name: donk-pocket pizza recipe
+  name: microwave-meal-recipe-donkpocket-pizza-name
   result: FoodPizzaDonkpocket
   time: 30
   group: Pizza
@@ -708,7 +710,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeUraniumPizza
-  name: spicy rock pizza recipe
+  name: microwave-meal-recipe-uranium-pizza-name
   result: FoodPizzaUranium
   time: 30
   group: Pizza
@@ -716,11 +718,12 @@
     FoodDoughFlat: 1
     FoodChiliPepper: 2
     FoodTomato: 2
-    SheetUranium1: 2
+  stacks:
+    Uranium: 2
 
 - type: microwaveMealRecipe
   id: RecipeCottonPizza
-  name: cotton pizza recipe
+  name: microwave-meal-recipe-cotton-pizza-name
   result: FoodPizzaCotton
   time: 30
   group: Moth
@@ -730,7 +733,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWorldpeasPizza
-  name: world peazza recipe
+  name: microwave-meal-recipe-worldpeas-pizza-name
   result: FoodPizzaWorldpeas
   time: 30
   solids:
@@ -740,7 +743,7 @@
 #Italian
 - type: microwaveMealRecipe
   id: RecipeBoiledSpaghetti
-  name: boiled spaghetti recipe
+  name: microwave-meal-recipe-boiled-spaghetti-name
   result: FoodNoodlesBoiled
   time: 15
   group: Pasta
@@ -751,7 +754,7 @@
 
 - type: microwaveMealRecipe
   id: RecipePastaTomato
-  name: pasta tomato recipe
+  name: microwave-meal-recipe-pasta-tomato-name
   result: FoodNoodles
   time: 10
   group: Pasta
@@ -761,7 +764,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMeatballSpaghetti
-  name: spaghetti & meatballs recipe
+  name: microwave-meal-recipe-meatball-spaghetti-name
   result: FoodNoodlesMeatball
   time: 10
   group: Pasta
@@ -771,7 +774,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeButterNoodles
-  name: butter noodles recipe
+  name: microwave-meal-recipe-butter-noodles-name
   result: FoodNoodlesButter
   time: 10
   group: Pasta
@@ -781,7 +784,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeChowMein
-  name: chow mein recipe
+  name: microwave-meal-recipe-chow-mein-name
   result: FoodNoodlesChowmein
   time: 10
   group: Pasta
@@ -795,7 +798,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeOatmeal
-  name: oatmeal recipe
+  name: microwave-meal-recipe-oatmeal-name
   result: FoodOatmeal
   time: 15
   group: Savory
@@ -807,7 +810,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBoiledRice
-  name: boiled rice recipe
+  name: microwave-meal-recipe-boiled-rice-name
   result: FoodRiceBoiled
   time: 15
   group: Savory
@@ -819,7 +822,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeRicePudding
-  name: rice pudding recipe
+  name: microwave-meal-recipe-rice-pudding-name
   result: FoodRicePudding
   time: 15
   group: Dessert
@@ -833,7 +836,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeRicePork
-  name: rice and pork recipe
+  name: microwave-meal-recipe-rice-pork-name
   result: FoodRicePork
   time: 15
   group: Savory
@@ -843,7 +846,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeRiceGumbo
-  name: black-eyed gumbo recipe
+  name: microwave-meal-recipe-rice-gumbo-name
   result: FoodRiceGumbo
   time: 15
   group: Savory
@@ -854,7 +857,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeEggRice
-  name: egg-fried rice recipe
+  name: microwave-meal-recipe-egg-rice-name
   result: FoodRiceEgg
   time: 15
   group: Savory
@@ -866,7 +869,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCopypasta
-  name: copypasta recipe
+  name: microwave-meal-recipe-copypasta-name
   result: FoodNoodlesCopy
   time: 10
   group: Pasta
@@ -877,7 +880,7 @@
 #Soups & Stew
 - type: microwaveMealRecipe
   id: RecipeBisque
-  name: bisque recipe
+  name: microwave-meal-recipe-bisque-name
   result: FoodSoupBisque
   time: 10
   group: Soup
@@ -891,7 +894,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMeatballSoup
-  name: meatball soup recipe
+  name: microwave-meal-recipe-meatball-soup-name
   result: FoodSoupMeatball
   time: 10
   group: Soup
@@ -905,7 +908,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeNettleSoup
-  name: nettle soup recipe
+  name: microwave-meal-recipe-nettle-soup-name
   result: FoodSoupNettle
   time: 10
   group: Soup
@@ -920,7 +923,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeEyeballSoup
-  name: eyeball soup recipe
+  name: microwave-meal-recipe-eyeball-soup-name
   result: FoodSoupEyeball
   time: 10
   group: Soup
@@ -934,7 +937,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeAmanitaJelly
-  name: amanita jelly recipe
+  name: microwave-meal-recipe-amanita-jelly-name
   result: FoodJellyAmanita
   time: 10
   group: Savory
@@ -946,7 +949,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeOnionSoup
-  name: onion soup recipe
+  name: microwave-meal-recipe-onion-soup-name
   result: FoodSoupOnion
   time: 10
   group: Soup
@@ -959,7 +962,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMushroomSoup
-  name: mushroom soup recipe
+  name: microwave-meal-recipe-mushroom-soup-name
   result: FoodSoupMushroom
   time: 10
   group: Soup
@@ -972,7 +975,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeStewSoup
-  name: stew recipe
+  name: microwave-meal-recipe-stew-soup-name
   result: FoodSoupStew
   time: 10
   group: Soup
@@ -989,7 +992,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTomatoSoup
-  name: tomato soup recipe
+  name: microwave-meal-recipe-tomato-soup-name
   result: FoodSoupTomato
   time: 10
   group: Soup
@@ -1001,7 +1004,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTomatoBloodSoup
-  name: tomato blood soup recipe
+  name: microwave-meal-recipe-tomato-blood-soup-name
   result: FoodSoupTomatoBlood
   time: 10
   group: Soup
@@ -1013,7 +1016,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWingFangChuSoup
-  name: wing fang chu recipe
+  name: microwave-meal-recipe-wing-fang-chu-soup-name
   result: FoodSoupWingFangChu
   time: 10
   group: Soup
@@ -1025,7 +1028,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWingFangChuSoupSpider
-  name: wing fang chu recipe
+  name: microwave-meal-recipe-wing-fang-chu-soup-spider-name
   result: FoodSoupWingFangChu
   time: 10
   group: Soup
@@ -1037,7 +1040,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeVegetableSoup
-  name: vegetable soup recipe
+  name: microwave-meal-recipe-vegetable-soup-name
   result: FoodSoupVegetable
   time: 10
   group: Soup
@@ -1052,7 +1055,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeClownTearsSoup
-  name: clown tears soup recipe
+  name: microwave-meal-recipe-clown-tears-soup-name
   result: FoodSoupClown
   time: 10
   group: Soup
@@ -1061,13 +1064,13 @@
   solids:
     FoodBowlBig: 1
     FoodBanana: 1
-    MaterialBananium: 1
     ShardGlass: 1
-    #idk probably replace shard with someting bananium when #14663 merged
+  stacks:
+    Bananium: 1
 
 - type: microwaveMealRecipe
   id: RecipeMonkeysDelightSoup
-  name: monkeys delight recipe
+  name: microwave-meal-recipe-monkeys-delight-soup-name
   result: FoodSoupMonkey
   time: 10
   group: Soup
@@ -1082,7 +1085,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBungoSoup
-  name: bungo soup recipe
+  name: microwave-meal-recipe-bungo-soup-name
   result: FoodSoupBungo
   time: 10
   group: Soup
@@ -1095,7 +1098,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBoiledSnail
-  name: boiled snail recipe
+  name: microwave-meal-recipe-boiled-snail-name
   result: FoodMeatSnailCooked
   time: 5
   group: Savory
@@ -1106,7 +1109,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeEscargotSoup
-  name: escargot recipe
+  name: microwave-meal-recipe-escargot-soup-name
   result: FoodSoupEscargot
   time: 10
   group: Soup
@@ -1123,7 +1126,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeAmanitaPie
-  name: amanita pie recipe
+  name: microwave-meal-recipe-amanita-pie-name
   result: FoodPieAmanita
   time: 15
   group: Pie
@@ -1134,7 +1137,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeApplePie
-  name: apple pie recipe
+  name: microwave-meal-recipe-apple-pie-name
   result: FoodPieApple
   time: 15
   group: Pie
@@ -1145,7 +1148,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBaklava
-  name: baklava recipe
+  name: microwave-meal-recipe-baklava-name
   result: FoodPieBaklava
   time: 15
   group: BarsAndCookies
@@ -1156,7 +1159,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBananaCreamPie
-  name: banana cream pie recipe
+  name: microwave-meal-recipe-banana-cream-pie-name
   result: FoodPieBananaCream
   time: 15
   group: Pie
@@ -1167,7 +1170,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBerryClafoutis
-  name: berry clafoutis recipe
+  name: microwave-meal-recipe-berry-clafoutis-name
   result: FoodPieClafoutis
   time: 15
   group: Pie
@@ -1178,7 +1181,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCherryPie
-  name: cherry pie recipe
+  name: microwave-meal-recipe-cherry-pie-name
   result: FoodPieCherry
   time: 15
   group: Pie
@@ -1189,7 +1192,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeFrostyPie
-  name: frosty pie recipe
+  name: microwave-meal-recipe-frosty-pie-name
   result: FoodPieFrosty
   time: 15
   group: Pie
@@ -1200,7 +1203,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMeatPie
-  name: meat pie recipe
+  name: microwave-meal-recipe-meat-pie-name
   result: FoodPieMeat
   time: 15
   group: Pie
@@ -1211,7 +1214,7 @@
 
 - type: microwaveMealRecipe
   id: RecipePumpkinPie
-  name: pumpkin pie recipe
+  name: microwave-meal-recipe-pumpkin-pie-name
   result: FoodPiePumpkin
   time: 15
   group: Pie
@@ -1226,13 +1229,13 @@
 #  result: FoodPiePlump
 #  time: 15
 #  solids:
-#    FoodDoughPie: 1
-#    FoodPlumpHelmet: 3 #a big part of me wants to veto this because the item description is a dick joke but i'll write the placeholder anyway
-#    FoodPlateTin: 1
+#  FoodDoughPie: 1
+#  FoodPlumpHelmet: 3 #a big part of me wants to veto this because the item description is a dick joke but i'll write the placeholder anyway
+#  FoodPlateTin: 1
 
 - type: microwaveMealRecipe
   id: RecipeXenoPie
-  name: xeno pie recipe
+  name: microwave-meal-recipe-xeno-pie-name
   result: FoodPieXeno
   time: 15
   group: Pie
@@ -1245,7 +1248,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCocoTart
-  name: chocolate lava tart recipe
+  name: microwave-meal-recipe-coco-tart-name
   result: FoodTartCoco
   time: 15
   group: Pie
@@ -1259,7 +1262,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeGappleTart
-  name: golden apple streusel tart recipe
+  name: microwave-meal-recipe-gapple-tart-name
   result: FoodTartGapple
   time: 15
   group: Pie
@@ -1274,7 +1277,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeGrapeTart
-  name: grape tart recipe
+  name: microwave-meal-recipe-grape-tart-name
   result: FoodTartGrape
   time: 15
   group: Pie
@@ -1288,7 +1291,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMimeTart
-  name: mime tart recipe
+  name: microwave-meal-recipe-mime-tart-name
   result: FoodTartMime
   time: 15
   group: Pie
@@ -1304,7 +1307,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCubanCarp
-  name: Cuban carp recipe
+  name: microwave-meal-recipe-cuban-carp-name
   result: FoodMealCubancarp
   time: 15
   group: Savory
@@ -1316,7 +1319,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSashimi
-  name: sashimi recipe
+  name: microwave-meal-recipe-sashimi-name
   result: FoodMealSashimi
   time: 15
   group: Savory
@@ -1327,7 +1330,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMisoColaSoup
-  name: salty sweet misocola soup recipe
+  name: microwave-meal-recipe-miso-cola-soup-name
   result: DisgustingSweptSoup
   time: 15
   group: Savory
@@ -1338,7 +1341,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeLoadedBakedPotato
-  name: loaded baked potato recipe
+  name: microwave-meal-recipe-loaded-baked-potato-name
   result: FoodMealPotatoLoaded
   time: 15
   group: Savory
@@ -1348,7 +1351,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeFries
-  name: space fries recipe
+  name: microwave-meal-recipe-fries-name
   result: FoodMealFries
   time: 15
   group: Savory
@@ -1359,7 +1362,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCheesyFries
-  name: cheesy fries recipe
+  name: microwave-meal-recipe-cheesy-fries-name
   result: FoodMealFriesCheesy
   time: 15
   group: Savory
@@ -1371,7 +1374,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCarrotFries
-  name: carrot fries recipe
+  name: microwave-meal-recipe-carrot-fries-name
   result: FoodMealFriesCarrot
   time: 15
   group: Savory
@@ -1382,7 +1385,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeNachos
-  name: nachos recipe
+  name: microwave-meal-recipe-nachos-name
   result: FoodMealNachos
   time: 10
   group: Savory
@@ -1394,7 +1397,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeNachosCheesy
-  name: cheesy nachos recipe
+  name: microwave-meal-recipe-nachos-cheesy-name
   result: FoodMealNachosCheesy
   time: 10
   group: Savory
@@ -1407,7 +1410,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeNachosCuban
-  name: cuban nachos recipe
+  name: microwave-meal-recipe-nachos-cuban-name
   result: FoodMealNachosCuban
   time: 10
   group: Savory
@@ -1420,7 +1423,7 @@
 
 - type: microwaveMealRecipe
   id: RecipePopcorn
-  name: popcorn recipe
+  name: microwave-meal-recipe-popcorn-name
   result: FoodSnackPopcorn
   time: 20
   group: Savory
@@ -1429,7 +1432,7 @@
 
 - type: microwaveMealRecipe
   id: RecipePancake
-  name: pancake recipe
+  name: microwave-meal-recipe-pancake-name
   result: FoodBakedPancake
   time: 5
   group: Breakfast
@@ -1440,7 +1443,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBlueberryPancake
-  name: blueberry pancake recipe
+  name: microwave-meal-recipe-blueberry-pancake-name
   result: FoodBakedPancakeBb
   time: 5
   group: Breakfast
@@ -1453,7 +1456,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWaffles
-  name: waffle recipe
+  name: microwave-meal-recipe-waffles-name
   result: FoodBakedWaffle
   time: 10
   group: Breakfast
@@ -1465,7 +1468,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWaffleSoy
-  name: soy waffle recipe
+  name: microwave-meal-recipe-waffle-soy-name
   result: FoodBakedWaffleSoy
   time: 10
   group: Breakfast
@@ -1477,7 +1480,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCookie
-  name: cookie recipe
+  name: microwave-meal-recipe-cookie-name
   result: FoodBakedCookie
   time: 5
   group: BarsAndCookies
@@ -1490,7 +1493,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSugarCookie
-  name: sugar cookie recipe
+  name: microwave-meal-recipe-sugar-cookie-name
   result: FoodBakedCookieSugar
   time: 5
   group: BarsAndCookies
@@ -1502,7 +1505,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeRaisinCookie
-  name: raisin cookie recipe
+  name: microwave-meal-recipe-raisin-cookie-name
   result: FoodBakedCookieRaisin
   time: 5
   group: BarsAndCookies
@@ -1514,7 +1517,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCookieOatmeal
-  name: oatmeal cookie recipe
+  name: microwave-meal-recipe-cookie-oatmeal-name
   result: FoodBakedCookieOatmeal
   time: 5
   group: BarsAndCookies
@@ -1526,7 +1529,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeChocolateChipPancake
-  name: chocolate chip pancake recipe
+  name: microwave-meal-recipe-chocolate-chip-pancake-name
   result: FoodBakedPancakeCc
   time: 5
   group: BarsAndCookies
@@ -1539,7 +1542,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeAppleCake
-  name: apple cake recipe
+  name: microwave-meal-recipe-apple-cake-name
   result: FoodCakeApple
   time: 5
   group: Cake
@@ -1549,7 +1552,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCarrotCake
-  name: carrot cake recipe
+  name: microwave-meal-recipe-carrot-cake-name
   result: FoodCakeCarrot
   time: 5
   group: Cake
@@ -1559,7 +1562,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeLemonCake
-  name: lemon cake recipe
+  name: microwave-meal-recipe-lemon-cake-name
   result: FoodCakeLemon
   time: 5
   group: Cake
@@ -1569,10 +1572,11 @@
 
 - type: microwaveMealRecipe
   id: RecipeLemoonCake
-  name: lemoon cake recipe
+  name: microwave-meal-recipe-lemoon-cake-name
   result: FoodCakeLemoon
   time: 5
   group: Cake
+  priority: 1 # Otherwise it breaks because of the berry cake recipe at higher portion counts
   solids:
     FoodCakePlain: 1
     FoodLemoon: 1
@@ -1580,7 +1584,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeOrangeCake
-  name: orange cake recipe
+  name: microwave-meal-recipe-orange-cake-name
   result: FoodCakeOrange
   time: 5
   group: Cake
@@ -1590,7 +1594,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBlueberryCake
-  name: blueberry cake recipe
+  name: microwave-meal-recipe-blueberry-cake-name
   result: FoodCakeBlueberry
   time: 5
   group: Cake
@@ -1600,7 +1604,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeLimeCake
-  name: lime cake recipe
+  name: microwave-meal-recipe-lime-cake-name
   result: FoodCakeLime
   time: 5
   group: Cake
@@ -1610,7 +1614,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCheeseCake
-  name: cheese cake recipe
+  name: microwave-meal-recipe-cheese-cake-name
   result: FoodCakeCheese
   time: 5
   group: Cake
@@ -1622,7 +1626,7 @@
 
 - type: microwaveMealRecipe
   id: RecipePumpkinCake
-  name: pumpkin cake recipe
+  name: microwave-meal-recipe-pumpkin-cake-name
   result: FoodCakePumpkin
   time: 5
   group: Cake
@@ -1632,7 +1636,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeClownCake
-  name: clown cake recipe
+  name: microwave-meal-recipe-clown-cake-name
   result: FoodCakeClown
   time: 5
   group: Cake
@@ -1642,7 +1646,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCake
-  name: cake recipe
+  name: microwave-meal-recipe-cake-name
   result: FoodCakePlain
   time: 15
   group: Cake
@@ -1651,7 +1655,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBirthdayCake
-  name: birthday cake recipe
+  name: microwave-meal-recipe-birthday-cake-name
   result: FoodCakeBirthday
   time: 5
   group: Cake
@@ -1662,7 +1666,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeChocolateCake
-  name: chocolate cake recipe
+  name: microwave-meal-recipe-chocolate-cake-name
   result: FoodCakeChocolate
   time: 5
   group: Cake
@@ -1672,7 +1676,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBrainCake
-  name: brain cake recipe
+  name: microwave-meal-recipe-brain-cake-name
   result: FoodCakeBrain
   time: 15
   group: Cake
@@ -1682,7 +1686,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeSlimeCake
-  name: slime cake recipe
+  name: microwave-meal-recipe-slime-cake-name
   result: FoodCakeSlime
   time: 5
   group: Cake
@@ -1693,7 +1697,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCatCake
-  name: cat cake recipe
+  name: microwave-meal-recipe-cat-cake-name
   result: MobCatCake
   time: 15
   group: Cake
@@ -1707,7 +1711,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBerryDelight
-  name: berry delight recipe
+  name: microwave-meal-recipe-berry-delight-name
   result: FoodCakeBerryDelight
   time: 5
   group: Cake
@@ -1719,7 +1723,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBreadDog
-  name: bread dog recipe
+  name: microwave-meal-recipe-bread-dog-name
   result: MobBreadDog
   time: 15
   group: Breads
@@ -1732,7 +1736,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDumplings
-  name: dumplings recipe
+  name: microwave-meal-recipe-dumplings-name
   result: FoodBakedDumplings
   time: 15
   group: Savory
@@ -1744,7 +1748,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBrownies
-  name: brownie recipe
+  name: microwave-meal-recipe-brownies-name
   result: FoodBakedBrownieBatch
   time: 25
   group: BarsAndCookies
@@ -1759,7 +1763,7 @@
 #Donks i guess
 - type: microwaveMealRecipe
   id: RecipeWarmDonkpocket
-  name: warm donk pocket recipe
+  name: microwave-meal-recipe-warm-donkpocket-name
   result: FoodDonkpocketWarm
   time: 5
   group: Savory
@@ -1768,7 +1772,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWarmDankpocket
-  name: warm dank pocket recipe
+  name: microwave-meal-recipe-warm-dankpocket-name
   result: FoodDonkpocketDankWarm
   time: 5
   group: Savory
@@ -1777,7 +1781,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWarmDonkpocketSpicy
-  name: warm spicy donk-pocket recipe
+  name: microwave-meal-recipe-warm-donkpocket-spicy-name
   result: FoodDonkpocketSpicyWarm
   time: 5
   group: Savory
@@ -1786,7 +1790,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWarmDonkpocketTeriyaki
-  name: warm teriyaki-pocket recipe
+  name: microwave-meal-recipe-warm-donkpocket-teriyaki-name
   result: FoodDonkpocketTeriyakiWarm
   time: 5
   group: Savory
@@ -1795,7 +1799,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWarmDonkpocketPizza
-  name: warm pizza-pocket recipe
+  name: microwave-meal-recipe-warm-donkpocket-pizza-name
   result: FoodDonkpocketPizzaWarm
   time: 5
   group: Savory
@@ -1804,7 +1808,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDonkpocketHonk
-  name: warm honk-pocket recipe
+  name: microwave-meal-recipe-donkpocket-honk-name
   result: FoodDonkpocketHonkWarm
   time: 5
   group: Savory
@@ -1813,7 +1817,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDonkpocketBerry
-  name: warm berry-pocket recipe
+  name: microwave-meal-recipe-donkpocket-berry-name
   result: FoodDonkpocketBerryWarm
   time: 5
   group: Savory
@@ -1822,7 +1826,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDonkpocketStonk
-  name: warm stonk-pocket recipe
+  name: microwave-meal-recipe-donkpocket-stonk-name
   result: FoodDonkpocketStonkWarm
   time: 5
   group: Savory
@@ -1831,7 +1835,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDonkpocketCarp
-  name: warm carp-pocket recipe
+  name: microwave-meal-recipe-donkpocket-carp-name
   result: FoodDonkpocketCarpWarm
   time: 5
   group: Savory
@@ -1840,7 +1844,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDonkpocketMoth
-  name: warm moth-pocket recipe
+  name: microwave-meal-recipe-donkpocket-moth-name
   result: FoodDonkpocketMothWarm
   time: 5
   solids:
@@ -1848,7 +1852,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeHotChili
-  name: hot chili recipe
+  name: microwave-meal-recipe-hot-chili-name
   result: FoodSoupChiliHot
   time: 20
   group: Soup
@@ -1861,7 +1865,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeColdChili
-  name: cold chili recipe
+  name: microwave-meal-recipe-cold-chili-name
   result: FoodSoupChiliCold
   time: 5
   group: Soup
@@ -1872,7 +1876,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeClownTears
-  name: clown's tears recipe
+  name: microwave-meal-recipe-clown-tears-name
   result: FoodSoupClown
   time: 15
   group: Soup
@@ -1884,7 +1888,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeChiliClown
-  name: chili con carnival recipe
+  name: microwave-meal-recipe-chili-clown-name
   result: FoodSoupChiliClown
   time: 30
   group: Soup
@@ -1898,20 +1902,19 @@
 
 - type: microwaveMealRecipe
   id: RecipeQueso
-  name: queso recipe
+  name: microwave-meal-recipe-queso-name
   result: FoodMealQueso
   time: 15
   group: Soup
-  #todo Add blackpepper
-  #reagents:
-    #blackpepper: 5
+  reagents:
+    Blackpepper: 5
   solids:
     FoodChiliPepper: 1
     FoodCheeseSlice: 2
 
 - type: microwaveMealRecipe
   id: RecipeRibs
-  name: BBQ ribs recipe
+  name: microwave-meal-recipe-ribs-name
   result: FoodMealRibs
   time: 15
   group: Savory
@@ -1923,7 +1926,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeEnchiladas
-  name: enchiladas recipe
+  name: microwave-meal-recipe-enchiladas-name
   result: FoodMealEnchiladas
   time: 20
   group: Savory
@@ -1935,7 +1938,7 @@
 # SALADS: These should be moved out of the microwave as soon as possible
 - type: microwaveMealRecipe
   id: RecipeHerbSalad
-  name: herb salad recipe
+  name: microwave-meal-recipe-herb-salad-name
   result: FoodSaladHerb
   time: 5
   group: Salad
@@ -1946,7 +1949,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeValidSalad
-  name: valid salad recipe
+  name: microwave-meal-recipe-valid-salad-name
   result: FoodSaladValid
   time: 5
   group: Salad
@@ -1958,7 +1961,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeColeslaw
-  name: coleslaw recipe
+  name: microwave-meal-recipe-coleslaw-name
   result: FoodSaladColeslaw
   time: 5
   group: Salad
@@ -1971,7 +1974,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCaesarSalad
-  name: caesar salad recipe
+  name: microwave-meal-recipe-caesar-salad-name
   result: FoodSaladCaesar
   time: 5
   group: Salad
@@ -1986,7 +1989,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCitrusSalad
-  name: citrus salad recipe
+  name: microwave-meal-recipe-citrus-salad-name
   result: FoodSaladCitrus
   time: 5
   group: Salad
@@ -1998,7 +2001,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeKimchiSalad
-  name: kimchi salad recipe
+  name: microwave-meal-recipe-kimchi-salad-name
   result: FoodSaladKimchi
   time: 5
   group: Salad
@@ -2012,7 +2015,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeFruitSalad
-  name: fruit salad recipe
+  name: microwave-meal-recipe-fruit-salad-name
   result: FoodSaladFruit
   time: 5
   group: Salad
@@ -2025,7 +2028,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeJungleSalad
-  name: jungle salad recipe
+  name: microwave-meal-recipe-jungle-salad-name
   result: FoodSaladJungle
   time: 5
   group: Salad
@@ -2038,7 +2041,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeWatermelonFruitBowlSalad
-  name: watermelon fruit bowl recipe
+  name: microwave-meal-recipe-watermelon-fruit-bowl-salad-name
   result: FoodSaladWatermelonFruitBowl
   time: 5
   group: Salad
@@ -2054,7 +2057,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMuffin
-  name: muffin recipe
+  name: microwave-meal-recipe-muffin-name
   result: FoodBakedMuffin
   time: 15
   group: Dessert
@@ -2066,7 +2069,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMuffinChocolate
-  name: chocolate muffin recipe
+  name: microwave-meal-recipe-muffin-chocolate-name
   result: FoodBakedMuffinChocolate
   time: 15
   group: Dessert
@@ -2079,7 +2082,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMuffinBerry
-  name: berry muffin recipe
+  name: microwave-meal-recipe-muffin-berry-name
   result: FoodBakedMuffinBerry
   time: 15
   group: Dessert
@@ -2092,7 +2095,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMuffinBanana
-  name: banana muffin recipe
+  name: microwave-meal-recipe-muffin-banana-name
   result: FoodBakedMuffinBanana
   time: 15
   group: Dessert
@@ -2105,7 +2108,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMuffinCherry
-  name: cherry muffin recipe
+  name: microwave-meal-recipe-muffin-cherry-name
   result: FoodBakedMuffinCherry
   time: 15
   group: Dessert
@@ -2120,7 +2123,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDriedTeaLeaves
-  name: dried tea leaves recipe
+  name: microwave-meal-recipe-dried-tea-leaves-name
   result: LeavesTeaDried
   time: 10
   solids:
@@ -2128,7 +2131,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDriedTobacco
-  name: dried tobacco leaves recipe
+  name: microwave-meal-recipe-dried-tobacco-name
   result: LeavesTobaccoDried
   time: 10
   group: Medicinal
@@ -2137,7 +2140,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDriedCannabis
-  name: dried cannabis leaves recipe
+  name: microwave-meal-recipe-dried-cannabis-name
   result: LeavesCannabisDried
   time: 10
   group: Medicinal
@@ -2146,7 +2149,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeDriedCannabisRainbow
-  name: dried rainbow cannabis leaves recipe
+  name: microwave-meal-recipe-dried-cannabis-rainbow-name
   result: LeavesCannabisRainbowDried
   time: 10
   group: Medicinal
@@ -2155,7 +2158,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTrashBakedBananaPeel
-  name: baked banana peel recipe
+  name: microwave-meal-recipe-trash-baked-banana-peel-name
   result: TrashBakedBananaPeel
   time: 5
   solids:
@@ -2164,7 +2167,7 @@
 # Suppermatter
 - type: microwaveMealRecipe
   id: RecipeSuppermatter
-  name: suppermatter recipe
+  name: microwave-meal-recipe-suppermatter-name
   result: FoodCakeSuppermatter
   time: 30
   solids:
@@ -2176,7 +2179,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeFoodBakedChevreChaud
-  name: chevre chaud recipe
+  name: microwave-meal-recipe-food-baked-chevre-chaud-name
   result: FoodBakedChevreChaud
   time: 5
   group: Savory
@@ -2186,7 +2189,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeFoodBakedChevreChaudCotton
-  name: cotton chevre chaud recipe
+  name: microwave-meal-recipe-food-baked-chevre-chaud-cotton-name
   result: FoodBakedChevreChaudCotton
   time: 5
   group: Moth
@@ -2196,7 +2199,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCannabisButter
-  name: cannabis butter recipe
+  name: microwave-meal-recipe-cannabis-butter-name
   result: FoodCannabisButter
   time: 15
   solids:
@@ -2205,7 +2208,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCannabisBrownies
-  name: cannabis brownie recipe
+  name: microwave-meal-recipe-cannabis-brownies-name
   result: FoodBakedCannabisBrownieBatch
   time: 25
   group: BarsAndCookies
@@ -2219,7 +2222,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCornInButter
-  name: corn in butter recipe
+  name: microwave-meal-recipe-corn-in-butter-name
   result: FoodMealCornInButter
   time: 10
   group: Savory
@@ -2230,7 +2233,7 @@
 
 - type: microwaveMealRecipe
   id: RecipePeaSoup
-  name: pea soup recipe
+  name: microwave-meal-recipe-pea-soup-name
   result: FoodSoupPea
   time: 10
   group: Soup
@@ -2242,16 +2245,16 @@
 
 - type: microwaveMealRecipe
   id: RecipeTacoShell
-  name: taco shell recipe
+  name: microwave-meal-recipe-taco-shell-name
   result: FoodTacoShell
   time: 5
   group: Breads
   solids:
-    FoodDoughTortillaFlat: 1 # one eighth a standard bread dough recipe
+    FoodDoughTortillaFlat: 1 # one eighth of a standard bread dough recipe
 
 - type: microwaveMealRecipe
   id: RecipeTacoBeef
-  name: beef taco recipe
+  name: microwave-meal-recipe-taco-beef-name
   result: FoodTacoBeef
   time: 10
   group: Savory
@@ -2262,7 +2265,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTacoChicken
-  name: chicken taco recipe
+  name: microwave-meal-recipe-taco-chicken-name
   result: FoodTacoChicken
   time: 10
   group: Savory
@@ -2273,7 +2276,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTacoFish
-  name: fish taco recipe
+  name: microwave-meal-recipe-taco-fish-name
   result: FoodTacoFish
   time: 10
   group: Savory
@@ -2286,7 +2289,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTacoRat
-  name: rat taco recipe
+  name: microwave-meal-recipe-taco-rat-name
   result: FoodTacoRat
   time: 10
   group: Savory
@@ -2297,7 +2300,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTacoBeefSupreme
-  name: beef taco supreme recipe
+  name: microwave-meal-recipe-taco-beef-supreme-name
   result: FoodTacoBeefSupreme
   time: 10
   group: Savory
@@ -2311,7 +2314,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTacoChickenSupreme
-  name: beef taco supreme recipe
+  name: microwave-meal-recipe-taco-chicken-supreme-name
   result: FoodTacoChickenSupreme
   time: 10
   group: Savory
@@ -2325,7 +2328,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeTacoDragon
-  name: draco recipe
+  name: microwave-meal-recipe-taco-dragon-name
   result: FoodTacoDragon
   time: 10
   group: Savory
@@ -2336,7 +2339,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCroissant
-  name: croissant recipe
+  name: microwave-meal-recipe-croissant-name
   result: FoodBakedCroissant
   time: 5
   group: Dessert
@@ -2346,7 +2349,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCroissantCotton
-  name: cotton croissant recipe
+  name: microwave-meal-recipe-croissant-cotton-name
   result: FoodBakedCroissantCotton
   time: 5
   group: Moth
@@ -2356,7 +2359,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeThrowingCroissant
-  name: throwing croissant recipe
+  name: microwave-meal-recipe-throwing-croissant-name
   result: WeaponCroissant
   secretRecipe: true
   time: 5
@@ -2368,7 +2371,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeInertAnomalyMeat
-  name: inert meat anomaly recipe
+  name: microwave-meal-recipe-inert-anomaly-meat-name
   result: FoodMeatAnomaly
   time: 5
   group: Savory
@@ -2377,7 +2380,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeAnomalyMeat
-  name: meat anomaly recipe
+  name: microwave-meal-recipe-anomaly-meat-name
   result: FoodMeatAnomaly
   time: 5
   group: Savory
@@ -2386,7 +2389,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeAnomalyMeatCooked
-  name: cooked meat anomaly recipe
+  name: microwave-meal-recipe-anomaly-meat-cooked-name
   result: FoodMeatAnomalyCooked
   time: 5
   group: Savory
@@ -2395,7 +2398,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeGrilledCheeseSandwich
-  name: grilled cheese sandwich recipe
+  name: microwave-meal-recipe-grilled-cheese-sandwich-name
   result: FoodBakedGrilledCheeseSandwich
   time: 10
   group: Savory
@@ -2406,7 +2409,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeGrilledCheeseSandwichCotton
-  name: cotton grilled cheese sandwich recipe
+  name: microwave-meal-recipe-grilled-cheese-sandwich-cotton-name
   result: FoodBakedGrilledCheeseSandwichCotton
   time: 10
   group: Moth
@@ -2417,7 +2420,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBreakfastAmerican
-  name: full american breakfast recipe
+  name: microwave-meal-recipe-breakfast-american-name
   result: FoodBreakfastAmerican
   time: 30
   group: Savory
@@ -2430,7 +2433,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeBreakfastEnglish
-  name: full english breakfast recipe
+  name: microwave-meal-recipe-breakfast-english-name
   result: FoodBreakfastEnglish
   time: 30
   group: Savory
@@ -2444,7 +2447,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeMoproach # TODO: Move this to be an actual surgery instead, once surgery gets implemented.
-  name: moproach recipe
+  name: microwave-meal-recipe-moproach-name
   result: MobMoproach
   time: 30
   group: Other
@@ -2457,7 +2460,7 @@
 
 - type: microwaveMealRecipe
   id: RecipeCottonCake
-  name: cotton cake recipe
+  name: microwave-meal-recipe-cotton-cake-name
   result: FoodCakeCotton
   time: 5
   group: Moth
diff --git a/Resources/Prototypes/Recipes/Cooking/medical_recipes.yml b/Resources/Prototypes/Recipes/Cooking/medical_recipes.yml
index 206ab848f6..f24f3bd96f 100644
--- a/Resources/Prototypes/Recipes/Cooking/medical_recipes.yml
+++ b/Resources/Prototypes/Recipes/Cooking/medical_recipes.yml
@@ -1,6 +1,6 @@
 - type: microwaveMealRecipe
   id: RecipeAloeCream
-  name: aloe cream recipe
+  name: microwave-meal-recipe-aloe-cream-name
   result: AloeCream
   time: 10
   group: Medicinal
@@ -9,28 +9,30 @@
 
 - type: microwaveMealRecipe
   id: RecipeMedicatedSuture
-  name: medicated suture recipe
+  name: microwave-meal-recipe-medicated-suture-name
   result: MedicatedSuture
   time: 10
   group: Medicinal
   solids:
     FoodPoppy: 1
-    Brutepack: 1
-    MaterialCloth1: 1
+  stacks:
+    Brutepack: 10
+    Cloth: 1
   reagents:
     TranexamicAcid: 20
     Cryptobiolin: 20
 
 - type: microwaveMealRecipe
   id: RecipeRegenerativeMesh
-  name: regenerative mesh recipe
+  name: microwave-meal-recipe-regenerative-mesh-name
   result: RegenerativeMesh
   time: 10
   group: Medicinal
   solids:
     FoodAloe: 1
-    Ointment: 1
-    MaterialCloth1: 1
+  stacks:
+    Ointment: 10
+    Cloth: 1
   reagents:
     Sigynate: 20
     Dermaline: 20