diff --git a/Content.Client/Entry/IgnoredComponents.cs b/Content.Client/Entry/IgnoredComponents.cs
index 83d6e142a2..b108266e4f 100644
--- a/Content.Client/Entry/IgnoredComponents.cs
+++ b/Content.Client/Entry/IgnoredComponents.cs
@@ -45,6 +45,9 @@ namespace Content.Client.Entry
             "DiseaseDiagnoser",
             "DiseaseVaccine",
             "DiseaseVaccineCreator",
+            "DiseaseZombie",
+            "DiseaseBuildup",
+            "ZombieTransfer",
             "Mineable",
             "RangedMagazine",
             "Ammo",
diff --git a/Content.Server/Body/Systems/BloodstreamSystem.cs b/Content.Server/Body/Systems/BloodstreamSystem.cs
index db6c4c1bbc..7b066360a9 100644
--- a/Content.Server/Body/Systems/BloodstreamSystem.cs
+++ b/Content.Server/Body/Systems/BloodstreamSystem.cs
@@ -226,6 +226,14 @@ public sealed class BloodstreamSystem : EntitySystem
         return (component.BloodSolution.CurrentVolume / component.BloodSolution.MaxVolume).Float();
     }
 
+    public void SetBloodLossThreshold(EntityUid uid, float threshold, BloodstreamComponent? comp = null)
+    {
+        if (!Resolve(uid, ref comp))
+            return;
+
+        comp.BloodlossThreshold = threshold;
+    }
+
     /// <summary>
     ///     Attempts to modify the blood level of this entity directly.
     /// </summary>
diff --git a/Content.Server/Disease/Components/DiseaseBuildupComponent.cs b/Content.Server/Disease/Components/DiseaseBuildupComponent.cs
new file mode 100644
index 0000000000..8c562b0662
--- /dev/null
+++ b/Content.Server/Disease/Components/DiseaseBuildupComponent.cs
@@ -0,0 +1,19 @@
+namespace Content.Server.Disease.Components
+{
+    /// <summary>
+    /// The component which records the buildup/progression of an infection
+    /// </summary>
+    [RegisterComponent]
+    public sealed class DiseaseBuildupComponent : Component
+    {
+        /// This could be served to be generalized to allow for multiple
+        /// diseases to build up at once, but it doesn't matter too much.
+
+        /// <summary>
+        /// The current amount of progression that has built up.
+        /// </summary>
+        [DataField("progression")]
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float Progression = 0.00f;
+    }
+}
diff --git a/Content.Server/Disease/DiseaseSystem.cs b/Content.Server/Disease/DiseaseSystem.cs
index 3d29338bad..82db96ddf2 100644
--- a/Content.Server/Disease/DiseaseSystem.cs
+++ b/Content.Server/Disease/DiseaseSystem.cs
@@ -94,8 +94,10 @@ namespace Content.Server.Disease
                     continue;
                 }
 
-                foreach (var disease in carrierComp.Diseases)
+                for (var i = 0; i < carrierComp.Diseases.Count; i++) //this is a for-loop so that it doesn't break when new diseases are added
                 {
+                    var disease = carrierComp.Diseases[i];
+
                     var args = new DiseaseEffectArgs(carrierComp.Owner, disease, EntityManager);
                     disease.Accumulator += frameTime;
                     if (disease.Accumulator >= disease.TickTime)
diff --git a/Content.Server/Disease/Effects/DiseaseProgression.cs b/Content.Server/Disease/Effects/DiseaseProgression.cs
new file mode 100644
index 0000000000..0fc35761a4
--- /dev/null
+++ b/Content.Server/Disease/Effects/DiseaseProgression.cs
@@ -0,0 +1,46 @@
+using Content.Server.Disease.Components;
+using JetBrains.Annotations;
+using Content.Shared.Disease;
+using Robust.Shared.IoC;
+
+namespace Content.Server.Disease.Effects
+{
+    /// <summary>
+    /// Handles a disease which incubates over a period of time
+    /// before adding another component to the infected entity
+    /// currently used for zombie virus
+    /// </summary>
+    [UsedImplicitly]
+    public sealed class DiseaseProgression : DiseaseEffect
+    {
+        /// <summary>
+        /// The rate that's increased over time. Defaults to 1% so the probability can be varied in yaml
+        /// </summary>
+        [DataField("rate")]
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float Rate = 0.01f;
+
+        /// <summary>
+        /// The component that is added at the end of build up
+        /// </summary>
+        [DataField("comp")]
+        public string? Comp = null;
+
+        public override void Effect(DiseaseEffectArgs args)
+        {
+            args.EntityManager.EnsureComponent<DiseaseBuildupComponent>(args.DiseasedEntity, out var buildup);
+            if (buildup.Progression < 1) //increases steadily until 100%
+            {
+                buildup.Progression += Rate;
+            }
+            else if (Comp != null)//adds the component for the later stage of the disease.
+            {
+                EntityUid uid = args.DiseasedEntity;
+                var newComponent = (Component) IoCManager.Resolve<IComponentFactory>().GetComponent(Comp);
+                newComponent.Owner = uid;
+                if (!args.EntityManager.HasComponent(uid, newComponent.GetType()))
+                    args.EntityManager.AddComponent(uid, newComponent);
+            }
+        }
+    }
+}
diff --git a/Content.Server/Disease/Zombie/Components/DiseaseZombieComponent.cs b/Content.Server/Disease/Zombie/Components/DiseaseZombieComponent.cs
new file mode 100644
index 0000000000..14cfcf7970
--- /dev/null
+++ b/Content.Server/Disease/Zombie/Components/DiseaseZombieComponent.cs
@@ -0,0 +1,37 @@
+namespace Content.Server.Disease.Zombie.Components
+{
+    /// <summary>
+    /// The component which gives an entity zombie traits.
+    /// </summary>
+    [RegisterComponent]
+    public sealed class DiseaseZombieComponent : Component
+    {
+        /// <summary>
+        /// The probability that a given bite will infect a player.
+        /// zombie infection is not based on disease resist items like masks or gloves.
+        /// </summary>
+        [DataField("probability")]
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float Probability = 0.33f;
+
+        /// <summary>
+        /// A multiplier on the movement speed that zombies recieve.
+        /// </summary>
+        [DataField("slowAmount")]
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float SlowAmount = 0.75f;
+
+        /// <summary>
+        /// Whether or not the zombie needs all the zombie traits initialized upon component init
+        /// useful for entities that already are zombies and do not need the additional traits.
+        /// </summary>
+        [DataField("applyZombieTraits")]
+        public bool ApplyZombieTraits = true;
+
+        /// <summary>
+        /// The color of the zombie's skin
+        /// </summary>
+        [DataField("skinColor")]
+        public readonly Color SkinColor = (0.70f, 0.72f, 0.48f, 1);
+    }
+}
diff --git a/Content.Server/Disease/Zombie/DiseaseZombieSystem.cs b/Content.Server/Disease/Zombie/DiseaseZombieSystem.cs
new file mode 100644
index 0000000000..0be6c14c55
--- /dev/null
+++ b/Content.Server/Disease/Zombie/DiseaseZombieSystem.cs
@@ -0,0 +1,139 @@
+using Robust.Shared.Containers;
+using Content.Server.Speech.Components;
+using Content.Server.Ghost.Roles.Components;
+using Content.Server.Disease.Components;
+using Content.Server.Disease.Zombie.Components;
+using Content.Server.Body.Components;
+using Content.Server.Body.Systems;
+using Content.Server.Popups;
+using Content.Server.Atmos.Components;
+using Content.Server.Hands.Components;
+using Content.Server.Nutrition.Components;
+using Content.Server.Mind.Components;
+using Content.Server.Chat.Managers;
+using Content.Shared.Damage;
+using Content.Shared.MobState.Components;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Movement.EntitySystems;
+using Content.Shared.CharacterAppearance.Components;
+using Content.Shared.CharacterAppearance.Systems;
+using Content.Server.Weapons.Melee.ZombieTransfer.Components;
+
+namespace Content.Server.Disease.Zombie
+{
+    /// <summary>
+    /// Handles zombie propagation and inherent zombie traits
+    /// </summary>
+    public sealed class DiseaseZombieSystem : EntitySystem
+    {
+        [Dependency] private readonly DamageableSystem _damageable = default!;
+        [Dependency] private readonly BloodstreamSystem _bloodstream = default!;
+        [Dependency] private readonly MovementSpeedModifierSystem _movementSpeedModifier = default!;
+        [Dependency] private readonly SharedHandsSystem _sharedHands = default!;
+        [Dependency] private readonly SharedHumanoidAppearanceSystem _sharedHumanoidAppearance = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<DiseaseZombieComponent, ComponentInit>(OnComponentInit);
+            SubscribeLocalEvent<DiseaseZombieComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshMovementSpeedModifiers);
+        }
+
+        /// <remarks>
+        /// I would imagine that if this component got assigned to something other than a mob, it would throw hella errors.
+        /// </remarks>
+        private void OnComponentInit(EntityUid uid, DiseaseZombieComponent component, ComponentInit args)
+        {
+            if (!component.ApplyZombieTraits || !HasComp<MobStateComponent>(uid))
+                return;
+
+            RemComp<DiseaseCarrierComponent>(uid);
+            RemComp<DiseaseBuildupComponent>(uid);
+            RemComp<RespiratorComponent>(uid);
+            RemComp<BarotraumaComponent>(uid);
+            RemComp<HungerComponent>(uid);
+            RemComp<ThirstComponent>(uid);
+
+            EntityManager.EnsureComponent<BloodstreamComponent>(uid, out var bloodstream); //zoms need bloodstream anyway for healing
+            _bloodstream.SetBloodLossThreshold(uid, 0f, bloodstream);
+            _bloodstream.TryModifyBleedAmount(uid, -bloodstream.BleedAmount, bloodstream);
+            _movementSpeedModifier.RefreshMovementSpeedModifiers(uid);
+            EntityManager.EnsureComponent<ReplacementAccentComponent>(uid).Accent = "zombie";
+
+            if (TryComp<DamageableComponent>(uid, out var comp))
+            {
+                _damageable.SetDamageModifierSetId(uid, "Zombie", comp);
+                _damageable.SetAllDamage(comp, 0);
+            }
+
+            if (TryComp<HumanoidAppearanceComponent>(uid, out var spritecomp))
+            {
+                var oldapp = spritecomp.Appearance;
+                var newapp = oldapp.WithSkinColor(component.SkinColor);
+                _sharedHumanoidAppearance.UpdateAppearance(uid, newapp);
+
+                _sharedHumanoidAppearance.ForceAppearanceUpdate(uid);
+            }
+
+            if (TryComp<HandsComponent>(uid, out var handcomp))
+            {
+                foreach (var hand in handcomp.Hands)
+                {
+                    _sharedHands.TrySetActiveHand(uid, hand.Key);
+                    _sharedHands.TryDrop(uid);
+
+                    var pos = EntityManager.GetComponent<TransformComponent>(uid).Coordinates;
+                    var virtualItem = EntityManager.SpawnEntity("ZombieClaw", pos);
+                    _sharedHands.DoPickup(uid, hand.Value, virtualItem);
+                }
+            }
+            else
+            {
+                EnsureComp<ZombieTransferComponent>(uid);
+            }
+
+            if (TryComp<ContainerManagerComponent>(uid, out var cmcomp))
+            {
+                foreach (var container in cmcomp.Containers)
+                {
+                    if (container.Value.ID == "gloves")
+                    {
+                        foreach (var entity in container.Value.ContainedEntities)
+                        {
+                            container.Value.Remove(entity);
+                        }
+                    }
+                }
+            }
+
+            if (TryComp<MindComponent>(uid, out var mindcomp))
+            {
+                if (mindcomp.Mind != null && mindcomp.Mind.TryGetSession(out var session))
+                {
+                    var chatMgr = IoCManager.Resolve<IChatManager>();
+                    chatMgr.DispatchServerMessage(session, Loc.GetString("zombie-infection-greeting"));
+                }
+            }
+
+            uid.PopupMessageEveryone(Loc.GetString("zombie-transform", ("target", uid)));
+            if (TryComp<MetaDataComponent>(uid, out var metacomp))
+            {
+                metacomp.EntityName = Loc.GetString("zombie-name-prefix", ("target", metacomp.EntityName));
+
+                if (!HasComp<GhostRoleMobSpawnerComponent>(uid)) //this specific component gives build test trouble so pop off, ig
+                {
+                    EntityManager.EnsureComponent<GhostTakeoverAvailableComponent>(uid, out var ghostcomp);
+                    ghostcomp.RoleName = metacomp.EntityName;
+                    ghostcomp.RoleDescription = Loc.GetString("zombie-role-desc");
+                    ghostcomp.RoleRules = Loc.GetString("zombie-role-rules");
+                }
+            }
+        }
+
+        private void OnRefreshMovementSpeedModifiers(EntityUid uid, DiseaseZombieComponent component, RefreshMovementSpeedModifiersEvent args)
+        {
+            args.ModifySpeed(component.SlowAmount, component.SlowAmount);
+        }
+    }
+}
diff --git a/Content.Server/StationEvents/Events/ZombieOutbreak.cs b/Content.Server/StationEvents/Events/ZombieOutbreak.cs
new file mode 100644
index 0000000000..43083c1587
--- /dev/null
+++ b/Content.Server/StationEvents/Events/ZombieOutbreak.cs
@@ -0,0 +1,54 @@
+using Robust.Shared.Random;
+using Content.Server.Chat.Managers;
+using Content.Server.Disease.Zombie.Components;
+using Content.Shared.MobState.Components;
+
+namespace Content.Server.StationEvents.Events
+{
+    /// <summary>
+    /// Revives several dead entities as zombies
+    /// </summary>
+    public sealed class ZombieOutbreak : StationEvent
+    {
+        [Dependency] private readonly IRobustRandom _random = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IChatManager _chatManager = default!;
+
+        public override string Name => "ZombieOutbreak";
+        public override float Weight => WeightLow;
+
+        public override string? StartAudio => "/Audio/Announcements/bloblarm.ogg";
+        protected override float EndAfter => 1.0f;
+
+        public override int? MaxOccurrences => 1;
+
+        /// <summary>
+        /// Finds 1-3 random, dead entities accross the station
+        /// and turns them into zombies.
+        /// </summary>
+        public override void Startup()
+        {
+            base.Startup();
+            List<MobStateComponent> deadList = new();
+            foreach (var mobState in _entityManager.EntityQuery<MobStateComponent>())
+            {
+                if (mobState.IsDead() || mobState.IsCritical())
+                    deadList.Add(mobState);
+            }
+            _random.Shuffle(deadList);
+
+            var toInfect = _random.Next(1, 3);
+
+            /// Now we give it to people in the list of dead entities earlier.
+            foreach (var target in deadList)
+            {
+                if (toInfect-- == 0)
+                    break;
+
+                _entityManager.EnsureComponent<DiseaseZombieComponent>(target.Owner);
+            }
+            _chatManager.DispatchStationAnnouncement(Loc.GetString("station-event-zombie-outbreak-announcement"),
+            playDefaultSound: false, colorOverride: Color.DarkMagenta);
+        }
+    }
+}
diff --git a/Content.Server/Weapon/Melee/ZombieTransfer/Components/ZombieTransferComponent.cs b/Content.Server/Weapon/Melee/ZombieTransfer/Components/ZombieTransferComponent.cs
new file mode 100644
index 0000000000..f0e95efb04
--- /dev/null
+++ b/Content.Server/Weapon/Melee/ZombieTransfer/Components/ZombieTransferComponent.cs
@@ -0,0 +1,7 @@
+namespace Content.Server.Weapons.Melee.ZombieTransfer.Components
+{
+    [RegisterComponent]
+    public sealed class ZombieTransferComponent : Component
+    {
+    }
+}
diff --git a/Content.Server/Weapon/Melee/ZombieTransfer/ZombieTransferSystem.cs b/Content.Server/Weapon/Melee/ZombieTransfer/ZombieTransferSystem.cs
new file mode 100644
index 0000000000..2f3c1b14c9
--- /dev/null
+++ b/Content.Server/Weapon/Melee/ZombieTransfer/ZombieTransferSystem.cs
@@ -0,0 +1,67 @@
+using System.Linq;
+using Robust.Shared.Random;
+using Content.Server.Body.Systems;
+using Content.Server.Disease.Components;
+using Content.Server.Disease.Zombie.Components;
+using Content.Server.Drone.Components;
+using Content.Server.Weapon.Melee;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Damage;
+using Content.Shared.MobState.Components;
+using Content.Server.Disease;
+using Content.Server.Weapons.Melee.ZombieTransfer.Components;
+
+namespace Content.Server.Weapons.Melee.ZombieTransfer
+{
+    public sealed class ZombieTransferSystem : EntitySystem
+    {
+        [Dependency] private readonly DiseaseSystem _disease = default!;
+        [Dependency] private readonly BloodstreamSystem _bloodstream = default!;
+        [Dependency] private readonly IRobustRandom _robustRandom = default!;
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<ZombieTransferComponent, MeleeHitEvent>(OnMeleeHit);
+        }
+
+        private void OnMeleeHit(EntityUid uid, ZombieTransferComponent component, MeleeHitEvent args)
+        {
+            if (!EntityManager.TryGetComponent<DiseaseZombieComponent>(args.User, out var diseaseZombieComp))
+                return;
+
+            if (!args.HitEntities.Any())
+                return;
+
+            foreach (EntityUid entity in args.HitEntities)
+            {
+                if (args.User == entity)
+                    continue;
+
+                if (!HasComp<MobStateComponent>(entity))
+                    continue;
+
+                if (_robustRandom.Prob(diseaseZombieComp.Probability) && HasComp<DiseaseCarrierComponent>(entity))
+                {
+                    _disease.TryAddDisease(entity, "ZombieInfection");
+                }
+
+                EntityManager.EnsureComponent<MobStateComponent>(entity, out var mobState);
+                if ((mobState.IsDead() || mobState.IsCritical()) && !HasComp<DiseaseZombieComponent>(entity)) //dead entities are eautomatically infected. MAYBE: have activated infect ability?
+                {
+                    EntityManager.AddComponent<DiseaseZombieComponent>(entity);
+                    var dspec = new DamageSpecifier();
+                    //these damages match the zombie claw
+                    dspec.DamageDict.TryAdd("Slash", -12);
+                    dspec.DamageDict.TryAdd("Piercing", -7);
+                    args.BonusDamage += dspec;
+                }
+                else if (mobState.IsAlive() && !HasComp<DroneComponent>(entity)) //heals when zombies bite live entities
+                {
+                    var healingSolution = new Solution();
+                    healingSolution.AddReagent("Bicaridine", 1.00); //if OP, reduce/change chem
+                    _bloodstream.TryAddToChemicals(args.User, healingSolution);
+                }
+            }
+        }
+    }
+}
diff --git a/Content.Shared/CharacterAppearance/Systems/SharedHumanoidAppearanceSystem.cs b/Content.Shared/CharacterAppearance/Systems/SharedHumanoidAppearanceSystem.cs
index 45b98ffde5..df7491e922 100644
--- a/Content.Shared/CharacterAppearance/Systems/SharedHumanoidAppearanceSystem.cs
+++ b/Content.Shared/CharacterAppearance/Systems/SharedHumanoidAppearanceSystem.cs
@@ -48,6 +48,17 @@ namespace Content.Shared.CharacterAppearance.Systems
             RaiseLocalEvent(uid, new ChangedHumanoidAppearanceEvent(appearance, sex, gender, species));
         }
 
+        public void UpdateAppearance(EntityUid uid, HumanoidCharacterAppearance appearance, HumanoidAppearanceComponent? component = null)
+        {
+            if (!Resolve(uid, ref component)) return;
+
+            component.Appearance = appearance;
+
+            component.Dirty();
+
+            RaiseLocalEvent(uid, new ChangedHumanoidAppearanceEvent(appearance, component.Sex, component.Gender, component.Species));
+        }
+
         private void OnAppearanceGetState(EntityUid uid, HumanoidAppearanceComponent component, ref ComponentGetState args)
         {
             args.State = new HumanoidAppearanceComponentState(component.Appearance, component.Sex, component.Gender, component.Species);
diff --git a/Content.Shared/Damage/Systems/DamageableSystem.cs b/Content.Shared/Damage/Systems/DamageableSystem.cs
index d2a198c329..958b45cd97 100644
--- a/Content.Shared/Damage/Systems/DamageableSystem.cs
+++ b/Content.Shared/Damage/Systems/DamageableSystem.cs
@@ -186,6 +186,16 @@ namespace Content.Shared.Damage
             DamageChanged(component, new DamageSpecifier());
         }
 
+        public void SetDamageModifierSetId(EntityUid uid, string damageModifierSetId, DamageableComponent? comp = null)
+        {
+            if (!Resolve(uid, ref comp))
+                return;
+
+            comp.DamageModifierSetId = damageModifierSetId;
+
+            Dirty(comp);
+        }
+        
         private void DamageableGetState(EntityUid uid, DamageableComponent component, ref ComponentGetState args)
         {
             args.State = new DamageableComponentState(component.Damage.DamageDict, component.DamageModifierSetId);
diff --git a/Resources/Locale/en-US/disease/zombie.ftl b/Resources/Locale/en-US/disease/zombie.ftl
new file mode 100644
index 0000000000..29c8d222bd
--- /dev/null
+++ b/Resources/Locale/en-US/disease/zombie.ftl
@@ -0,0 +1,6 @@
+zombie-transform = {CAPITALIZE(THE($target))} turned into a zombie!
+zombie-infection-greeting = You have become a zombie. Your goal is to seek out the living and to try to infect them. Work together with your fellow zombies to overpower the remaining crewmates.
+
+zombie-name-prefix = zombified {$target}
+zombie-role-desc =  A malevolent creature of the dead.
+zombie-role-rules = You are an antagonist. Search out the living and bite them in order to infect them and turn them into zombies. Work together with other the zombies to overtake the station.
diff --git a/Resources/Locale/en-US/station-events/events/zombie-outbreak.ftl b/Resources/Locale/en-US/station-events/events/zombie-outbreak.ftl
new file mode 100644
index 0000000000..da6d8fa4f1
--- /dev/null
+++ b/Resources/Locale/en-US/station-events/events/zombie-outbreak.ftl
@@ -0,0 +1 @@
+station-event-zombie-outbreak-announcement = Confirmed sightings of various undead aboard the station. All personnel should arm themselves, barricade doors, and secure their location in order to prevent further infection.
\ No newline at end of file
diff --git a/Resources/Prototypes/Damage/modifier_sets.yml b/Resources/Prototypes/Damage/modifier_sets.yml
index 98bfe724d2..2c242ebb21 100644
--- a/Resources/Prototypes/Damage/modifier_sets.yml
+++ b/Resources/Prototypes/Damage/modifier_sets.yml
@@ -104,6 +104,17 @@
     Heat: 0.9
     Poison: 0.9
 
+- type: damageModifierSet
+  id: Zombie #Blunt resistent and immune to biological threats, but can be hacked apart and burned
+  coefficients:
+    Blunt: 0.4
+    Slash: 0.8
+    Piercing: 0.9
+    Shock: 0.8
+    Cold: 0.2
+    Heat: 3.0
+    Poison: 0.0
+
 # Represents which damage types should be modified
 # in relation to how they cause bloodloss damage.
 - type: damageModifierSet
diff --git a/Resources/Prototypes/Diseases/noninfectious.yml b/Resources/Prototypes/Diseases/noninfectious.yml
index af1a722d09..4ad5e27be1 100644
--- a/Resources/Prototypes/Diseases/noninfectious.yml
+++ b/Resources/Prototypes/Diseases/noninfectious.yml
@@ -15,4 +15,29 @@
     - !type:DiseaseReagentCure
       reagent: Phalanximine
       min: 15
+
 ### Once radiation is refactored I want it to have a small chance of giving you regular cancer
+
+- type: disease
+  id: ZombieInfection
+  name: Zombie Infection #This is the incubation period of the zombie disease.
+  infectious: false
+  cureResist: 0.2
+  effects:
+    - !type:DiseaseHealthChange
+      probability: 0.05
+      damage:
+        types:
+          Blunt: 3
+    - !type:DiseaseSnough
+      probability: 0.005
+      snoughMessage: disease-cough
+      snoughSound:
+        collection: Coughs
+    - !type:DiseaseProgression
+      probability: 0.5
+      comp: DiseaseZombie
+  cures:
+    - !type:DiseaseReagentCure
+      reagent: Romerol
+      min: 10
diff --git a/Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml b/Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml
index 4a09a05415..c9d4220cb5 100644
--- a/Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml
+++ b/Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml
@@ -35,3 +35,13 @@
   - type: HealthAnalyzer
     fake: true
     disease: OwOnavirus
+
+- type: entity
+  parent: HandheldHealthAnalyzer
+  id: HandheldHealthAnalyzerZombie
+  name: Zombie Infector
+  suffix: DEBUG
+  components:
+  - type: HealthAnalyzer
+    fake: true
+    disease: ZombieInfection
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Objects/Weapons/Melee/zombieclaw.yml b/Resources/Prototypes/Entities/Objects/Weapons/Melee/zombieclaw.yml
new file mode 100644
index 0000000000..794b2c5596
--- /dev/null
+++ b/Resources/Prototypes/Entities/Objects/Weapons/Melee/zombieclaw.yml
@@ -0,0 +1,21 @@
+# Special entity used to fill zombie's hands when they turn undead
+- type: entity
+  id: ZombieClaw
+  name: Zombie Claw
+  noSpawn: true
+  components:
+    - type: Sprite
+      sprite: Objects/Weapons/Melee/zombie_claw.rsi
+      state: icon
+    - type: Item
+    - type: ZombieTransfer
+    - type: Unremoveable
+    - type: MeleeWeapon
+      damage:
+        types:
+          Slash: 13
+          Piercing: 7
+      range: 1
+      arcwidth: 0
+      arc: claw
+
diff --git a/Resources/Prototypes/Entities/Structures/Wallmounts/Signs/signs.yml b/Resources/Prototypes/Entities/Structures/Wallmounts/Signs/signs.yml
index 4523c7c85b..e29fdbafc6 100644
--- a/Resources/Prototypes/Entities/Structures/Wallmounts/Signs/signs.yml
+++ b/Resources/Prototypes/Entities/Structures/Wallmounts/Signs/signs.yml
@@ -726,6 +726,14 @@
   - type: Sprite
     state: xenolab
 
+- type: entity
+  parent: BaseSign
+  id: SignZomlab
+  name: zombie lab sign
+  components:
+  - type: Sprite
+    state: zomlab
+
 - type: entity
   parent: BaseSign
   id: SignSecureMedRed
diff --git a/Resources/Prototypes/Reagents/medicine.yml b/Resources/Prototypes/Reagents/medicine.yml
index bfdddeea2f..df074697a8 100644
--- a/Resources/Prototypes/Reagents/medicine.yml
+++ b/Resources/Prototypes/Reagents/medicine.yml
@@ -319,6 +319,21 @@
             Cellular: -1
             Radiation: 1
 
+- type: reagent
+  id: Romerol
+  name: romerol
+  group: Medicine
+  desc: A difficult to procure chemical used in the reversal of the zombification process. Tastes like death.
+  physicalDesc: acrid
+  color: "#7e916e"
+  metabolisms:
+    Medicine:
+      effects:
+      - !type:HealthChange
+        damage:
+          types:
+            Poison: 2
+
 - type: reagent
   id: PulpedBananaPeel
   name: pulped banana peel
diff --git a/Resources/Prototypes/Recipes/Reactions/medicine.yml b/Resources/Prototypes/Recipes/Reactions/medicine.yml
index 57e0ebc4f9..443479d0ba 100644
--- a/Resources/Prototypes/Recipes/Reactions/medicine.yml
+++ b/Resources/Prototypes/Recipes/Reactions/medicine.yml
@@ -189,6 +189,16 @@
   products:
     Phalanximine: 3
 
+- type: reaction
+  id: Romerol
+  reactants:
+    Phalanximine:
+      amount: 1
+    Tricordrazine:
+      amount: 1
+  products:
+    Romerol: 2
+
 - type: reaction
   id: Synaptizine
   reactants:
diff --git a/Resources/Prototypes/accents.yml b/Resources/Prototypes/accents.yml
index 45fd9491f3..2b62fddd81 100644
--- a/Resources/Prototypes/accents.yml
+++ b/Resources/Prototypes/accents.yml
@@ -47,6 +47,14 @@
     - Hisssuuu...
     - Hiss...!
 
+- type: accent
+  id: zombie
+  words:
+    - Gruaahhhh...
+    - Mmuaaaa..
+    - Braainnssss...
+    - Grrrrr...
+
 - type: accent
   id: genericAggressive
   words:
diff --git a/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/icon.png b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/icon.png
new file mode 100644
index 0000000000..361dfbf844
Binary files /dev/null and b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/icon.png differ
diff --git a/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/inhand-left.png b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/inhand-left.png
new file mode 100644
index 0000000000..7cb0ee924a
Binary files /dev/null and b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/inhand-left.png differ
diff --git a/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/inhand-right.png b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/inhand-right.png
new file mode 100644
index 0000000000..69a0bef26f
Binary files /dev/null and b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/inhand-right.png differ
diff --git a/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/meta.json b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/meta.json
new file mode 100644
index 0000000000..a0d45845d1
--- /dev/null
+++ b/Resources/Textures/Objects/Weapons/Melee/zombie_claw.rsi/meta.json
@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "license": "CC-BY-SA-3.0",
+  "copyright": "Illustrated by EmoGarbage",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "icon"
+    },
+    {
+      "name": "inhand-left",
+      "directions": 4
+    },
+    {
+      "name": "inhand-right",
+      "directions": 4
+    }
+  ]
+}
diff --git a/Resources/Textures/Structures/Wallmounts/signs.rsi/meta.json b/Resources/Textures/Structures/Wallmounts/signs.rsi/meta.json
index 39e8bab3b3..e389951cab 100644
--- a/Resources/Textures/Structures/Wallmounts/signs.rsi/meta.json
+++ b/Resources/Textures/Structures/Wallmounts/signs.rsi/meta.json
@@ -975,6 +975,14 @@
         ]
       ]
     },
+    {
+      "name": "zomlab",
+      "delays": [
+        [
+          1
+        ]
+      ]
+    },
     {
       "name": "small_secure_red",
       "delays": [
diff --git a/Resources/Textures/Structures/Wallmounts/signs.rsi/zomlab.png b/Resources/Textures/Structures/Wallmounts/signs.rsi/zomlab.png
new file mode 100644
index 0000000000..09d54e603d
Binary files /dev/null and b/Resources/Textures/Structures/Wallmounts/signs.rsi/zomlab.png differ