diff --git a/proprietary/images/doomsdayicon.png b/proprietary/images/doomsdayicon.png
new file mode 100644
index 000000000..4750b2cc7
Binary files /dev/null and b/proprietary/images/doomsdayicon.png differ
diff --git a/resources/lang/en.json b/resources/lang/en.json
index 37934c1a0..ec7dffb01 100644
--- a/resources/lang/en.json
+++ b/resources/lang/en.json
@@ -270,7 +270,8 @@
     "factory": "Factory",
     "airfield": "Airfield",
     "air_field": "Airfield",
-    "fighter_jet": "Fighter Jet"
+    "fighter_jet": "Fighter Jet",
+    "doomsday_device": "Doomsday Device"
   },
   "user_setting": {
     "title": "User Settings",
@@ -487,7 +488,8 @@
       "hospital": "Lowers troop casualties from combat",
       "academy": "Increases troop speed and enemy losses in combat",
       "airfield": "Send bombers, fighterjets and paratroopers",
-      "fighter_jet": "Destroys bombers and fighters jets"
+      "fighter_jet": "Destroys bombers and fighters jets",
+      "doomsday_device": "A mysterious device with unknown effects"
     },
     "not_enough_money": "Not enough money"
   },
@@ -554,9 +556,8 @@
     "reject_alliance": "Reject",
     "alliance_renewed": "Your alliance with {name} has been renewed",
     "ignore": "Ignore",
-    "paratrooper_sent": "Paratrooper"
-  },
-  "game_messages": {
+    "paratrooper_sent": "Paratrooper",
+    "doomsday_triggered": "{player}'s Doomsday Device has been Triggered!",
     "max_paratrooper_units_reached": "Maximum number of paratrooper planes reached.",
     "incoming_paratrooper_attack": "Incoming Paratrooper Attack from {attackerName}"
   },
diff --git a/resources/lang/tr.json b/resources/lang/tr.json
index 4185669f8..a992b5765 100644
--- a/resources/lang/tr.json
+++ b/resources/lang/tr.json
@@ -554,9 +554,7 @@
     "reject_alliance": "Reddet",
     "alliance_renewed": "{name} ile ittifakınız yenilendi",
     "ignore": "Yoksay",
-    "paratrooper_sent": "Paraşütçü"
-  },
-  "game_messages": {
+    "paratrooper_sent": "Paraşütçü",
     "max_paratrooper_units_reached": "Maksimum paraşütçü uçağı sayısına ulaşıldı.",
     "incoming_paratrooper_attack": "{attackerName} tarafından Gelen Paraşütçü Saldırısı"
   },
diff --git a/src/client/Utils.ts b/src/client/Utils.ts
index 14697d7e2..890d1927f 100644
--- a/src/client/Utils.ts
+++ b/src/client/Utils.ts
@@ -196,6 +196,7 @@ export function getMessageTypeClasses(type: MessageType): string {
     case MessageType.WARN:
     case MessageType.PEACE_TIMER_BLOCKED:
     case MessageType.TRADE_SHIP_TURNED_AROUND:
+    case MessageType.DOOMSDAY_DEVICE_ACTIVATED:
       return severityColors["warn"];
     case MessageType.WAR_DECLARED:
       return severityColors["warn"]; // war start: highlight prominently
diff --git a/src/client/graphics/fx/NukeFx.ts b/src/client/graphics/fx/NukeFx.ts
index 080f2d4f8..ba5382e05 100644
--- a/src/client/graphics/fx/NukeFx.ts
+++ b/src/client/graphics/fx/NukeFx.ts
@@ -131,3 +131,90 @@ export function nukeFxFactory(
   }
   return nukeFx;
 }
+
+/**
+ * Slower, larger, more lingering FX for Doomsday device trigger.
+ * - Larger shockwave (longer duration)
+ * - Higher density lingering smoke/fire with longer fade
+ */
+export function doomsdayFxFactory(
+  animatedSpriteLoader: AnimatedSpriteLoader,
+  x: number,
+  y: number,
+  radius: number,
+  game: GameView,
+  scale: number = 1.2,
+): Fx[] {
+  const fx: Fx[] = [];
+  // Central sustained explosion sprite (scaled up)
+  fx.push(
+    new SpriteFx(
+      animatedSpriteLoader,
+      x,
+      y,
+      FxType.Nuke,
+      undefined,
+      undefined,
+      undefined,
+      scale,
+    ),
+  );
+  // Slower shockwave (duration 6000ms, larger reach)
+  fx.push(new ShockwaveFx(x, y, 6000, radius * 2));
+  // Lingering debris plan (higher density, longer fade via FadeFx wrapper)
+  const debrisPlan: Array<{
+    type: FxType;
+    radiusFactor: number;
+    density: number;
+    fadeIn: number;
+    fadeOut: number;
+  }> = [
+    {
+      type: FxType.MiniFire,
+      radiusFactor: 1.3,
+      density: 1 / 18,
+      fadeIn: 0.2,
+      fadeOut: 1.5,
+    },
+    {
+      type: FxType.MiniSmoke,
+      radiusFactor: 1.4,
+      density: 1 / 20,
+      fadeIn: 0.2,
+      fadeOut: 1.8,
+    },
+    {
+      type: FxType.MiniBigSmoke,
+      radiusFactor: 1.2,
+      density: 1 / 50,
+      fadeIn: 0.2,
+      fadeOut: 2.0,
+    },
+    {
+      type: FxType.MiniSmokeAndFire,
+      radiusFactor: 1.1,
+      density: 1 / 55,
+      fadeIn: 0.2,
+      fadeOut: 2.2,
+    },
+  ];
+  for (const { type, radiusFactor, density, fadeIn, fadeOut } of debrisPlan) {
+    const count = Math.max(0, Math.floor(radius * density));
+    for (let i = 0; i < count; i++) {
+      const angle = Math.random() * 2 * Math.PI;
+      const distance = Math.random() * (radius * radiusFactor);
+      const sx = Math.floor(x + Math.cos(angle) * distance * 0.5);
+      const sy = Math.floor(y + Math.sin(angle) * distance * 0.5);
+      if (game.isValidCoord(sx, sy) && game.isLand(game.ref(sx, sy))) {
+        fx.push(
+          new FadeFx(
+            new SpriteFx(animatedSpriteLoader, sx, sy, type),
+            fadeIn,
+            fadeOut,
+          ) as Fx,
+        );
+      }
+    }
+  }
+  return fx;
+}
diff --git a/src/client/graphics/layers/BuildMenu.ts b/src/client/graphics/layers/BuildMenu.ts
index 0d81bf4a8..79562ff4b 100644
--- a/src/client/graphics/layers/BuildMenu.ts
+++ b/src/client/graphics/layers/BuildMenu.ts
@@ -1,5 +1,6 @@
 import { LitElement, css, html } from "lit";
 import { customElement, property, state } from "lit/decorators.js";
+import doomsdayDeviceIcon from "../../../../proprietary/images/doomsdayicon.png";
 import researchLabIcon from "../../../../proprietary/images/researchlab.png";
 import airfieldIcon from "../../../../resources/images/AirfieldIcon.svg";
 import warshipIcon from "../../../../resources/images/BattleshipIconWhite.svg";
@@ -154,6 +155,13 @@ const buildTable: BuildItemDisplay[][] = [
       key: "unit_type.defense_post",
       countable: true,
     },
+    {
+      unitType: UnitType.DoomsdayDevice,
+      icon: doomsdayDeviceIcon,
+      description: "build_menu.desc.doomsday_device",
+      key: "unit_type.doomsday_device",
+      countable: true,
+    },
   ],
 ];
 
diff --git a/src/client/graphics/layers/ControlPanel2.ts b/src/client/graphics/layers/ControlPanel2.ts
index 8b6bad681..e65971d44 100644
--- a/src/client/graphics/layers/ControlPanel2.ts
+++ b/src/client/graphics/layers/ControlPanel2.ts
@@ -145,6 +145,7 @@ export class ControlPanel2 extends LitElement implements Layer {
     "SAM Launcher": "/images/SamLauncherIconWhite.svg",
     "Air Field": "/images/AirfieldIcon.svg",
     "Defense Post": "/images/ShieldIconWhite.svg",
+    "Doomsday Device": "/images/Doomsdayicon.png",
   };
 
   // Per-unit icon scale used for small inline icons in this panel
@@ -159,6 +160,7 @@ export class ControlPanel2 extends LitElement implements Layer {
     [UnitType.SAMLauncher]: 1,
     [UnitType.Airfield]: 1,
     [UnitType.DefensePost]: 1,
+    [UnitType.DoomsdayDevice]: 1,
   };
 
   private iconPixelSize(t: UnitType | null, base = 16): number {
@@ -198,6 +200,7 @@ export class ControlPanel2 extends LitElement implements Layer {
     UnitType.Academy,
     UnitType.Factory,
     UnitType.City,
+    UnitType.DoomsdayDevice,
   ];
 
   private readonly investmentRequestHandler = (event: Event) => {
@@ -1364,6 +1367,7 @@ export class ControlPanel2 extends LitElement implements Layer {
                                 UnitType.Academy,
                                 UnitType.ResearchLab,
                                 UnitType.Factory,
+                                UnitType.DoomsdayDevice,
                               ].map((s) => {
                                 return html`
                                   <label
diff --git a/src/client/graphics/layers/EventsDisplay.ts b/src/client/graphics/layers/EventsDisplay.ts
index 180e08819..9c0c6c2af 100644
--- a/src/client/graphics/layers/EventsDisplay.ts
+++ b/src/client/graphics/layers/EventsDisplay.ts
@@ -729,19 +729,7 @@ export class EventsDisplay extends LitElement implements Layer {
 
     const unitView = this.game.unit(event.unitID);
 
-    let translatedDescription = event.message;
-
-    if (event.messageType === MessageType.PARATROOPER_INBOUND) {
-      const match = event.message.match(/from (.*)/);
-      const attackerName = match ? match[1] : "Unknown Attacker";
-
-      translatedDescription = translateText(
-        "game_messages.incoming_paratrooper_attack",
-        {
-          attackerName: attackerName,
-        },
-      );
-    }
+    const translatedDescription = event.message;
 
     this.addEvent({
       description: translatedDescription,
diff --git a/src/client/graphics/layers/FxLayer.ts b/src/client/graphics/layers/FxLayer.ts
index dd3167a99..6e9d637e8 100644
--- a/src/client/graphics/layers/FxLayer.ts
+++ b/src/client/graphics/layers/FxLayer.ts
@@ -4,7 +4,7 @@ import { GameUpdateType } from "../../../core/game/GameUpdates";
 import { GameView, UnitView } from "../../../core/game/GameView";
 import { AnimatedSpriteLoader } from "../AnimatedSpriteLoader";
 import { Fx, FxType } from "../fx/Fx";
-import { nukeFxFactory, ShockwaveFx } from "../fx/NukeFx";
+import { doomsdayFxFactory, nukeFxFactory, ShockwaveFx } from "../fx/NukeFx";
 import { SpriteFx } from "../fx/SpriteFx";
 import { UnitExplosionFx } from "../fx/UnitExplosionFx";
 import { Layer } from "./Layer";
@@ -57,6 +57,22 @@ export class FxLayer implements Layer {
           this.allFx.push(fx);
         }
       });
+
+    this.game
+      .updatesSinceLastTick()
+      ?.[GameUpdateType.DoomsdayExplosion]?.forEach((update) => {
+        const { x, y, radius } = update;
+        const doomFx = doomsdayFxFactory(
+          this.animatedSpriteLoader,
+          x,
+          y,
+          radius,
+          this.game,
+        );
+        for (const fx of doomFx) {
+          this.allFx.push(fx);
+        }
+      });
   }
 
   onUnitEvent(unit: UnitView) {
diff --git a/src/client/graphics/layers/StructureLayer.ts b/src/client/graphics/layers/StructureLayer.ts
index 816cc6463..ac2531896 100644
--- a/src/client/graphics/layers/StructureLayer.ts
+++ b/src/client/graphics/layers/StructureLayer.ts
@@ -1,6 +1,7 @@
 import { colord } from "colord";
 import * as PIXI from "pixi.js";
 import airfieldIcon from "../../../../proprietary/images/airfieldicon2.png";
+import doomsdayDeviceIcon from "../../../../proprietary/images/doomsdayicon.png";
 import researchLabIcon from "../../../../proprietary/images/researchlab.png";
 import anchorIcon from "../../../../resources/images/AnchorIcon.png";
 import academyIcon from "../../../../resources/images/buildings/academy_icon.png";
@@ -65,6 +66,7 @@ const STRUCTURE_BG_SHAPES: Partial<Record<UnitType, BgShape>> = {
   [UnitType.ResearchLab]: "square",
   [UnitType.Academy]: "square",
   [UnitType.Factory]: "circle",
+  [UnitType.DoomsdayDevice]: "square",
 };
 
 export class StructureLayer implements Layer {
@@ -114,6 +116,7 @@ export class StructureLayer implements Layer {
     [UnitType.Port, { iconPath: anchorIcon, image: null }],
     [UnitType.MissileSilo, { iconPath: missileSiloIcon, image: null }],
     [UnitType.SAMLauncher, { iconPath: SAMMissileIcon, image: null }],
+    [UnitType.DoomsdayDevice, { iconPath: doomsdayDeviceIcon, image: null }],
   ]);
 
   // Per-structure icon scale factor (1 = default size)
@@ -128,6 +131,7 @@ export class StructureLayer implements Layer {
     [UnitType.Port]: 1,
     [UnitType.MissileSilo]: 1,
     [UnitType.SAMLauncher]: 1,
+    [UnitType.DoomsdayDevice]: 1.4,
   };
 
   constructor(
@@ -727,6 +731,7 @@ export class StructureLayer implements Layer {
       UnitType.Academy,
       UnitType.ResearchLab,
       UnitType.Factory,
+      UnitType.DoomsdayDevice,
     ]);
     if (centerScaledTypes.has(structureType as UnitType)) {
       const padded = 4;
diff --git a/src/core/configuration/DefaultConfig.ts b/src/core/configuration/DefaultConfig.ts
index 05fc0226a..13422d90d 100644
--- a/src/core/configuration/DefaultConfig.ts
+++ b/src/core/configuration/DefaultConfig.ts
@@ -818,7 +818,7 @@ export class DefaultConfig implements Config {
                   ),
                 ),
           territoryBound: true,
-          constructionDuration: this.instantBuild() ? 0 : 2 * 20,
+          constructionDuration: this.instantBuild() ? 0 : 10 * 10,
           maxHealth: 1000,
         };
       case UnitType.CargoPlane:
@@ -851,6 +851,16 @@ export class DefaultConfig implements Config {
           cost: () => 0n,
           territoryBound: false,
         };
+      case UnitType.DoomsdayDevice:
+        return {
+          cost: (p: Player) =>
+            p.type() === PlayerType.Human && this.infiniteGold()
+              ? 0n
+              : 50_000_000n,
+          territoryBound: true,
+          constructionDuration: this.instantBuild() ? 0 : 10 * 10,
+          maxHealth: 3000,
+        };
       default:
         assertNever(type);
     }
diff --git a/src/core/execution/AirfieldExecution.ts b/src/core/execution/AirfieldExecution.ts
index 807285962..ff1beb99a 100644
--- a/src/core/execution/AirfieldExecution.ts
+++ b/src/core/execution/AirfieldExecution.ts
@@ -150,6 +150,9 @@ export class AirfieldExecution implements Execution {
         UnitType.City,
         UnitType.Academy,
         UnitType.Hospital,
+        UnitType.DoomsdayDevice,
+        UnitType.Factory,
+        UnitType.ResearchLab,
       ])
       .filter(({ unit }) => {
         const o = mg.owner(unit.tile());
@@ -174,6 +177,9 @@ export class AirfieldExecution implements Execution {
       UnitType.City,
       UnitType.Academy,
       UnitType.Hospital,
+      UnitType.DoomsdayDevice,
+      UnitType.Factory,
+      UnitType.ResearchLab,
     ];
 
     const sortedEnemies = enemies.sort((a, b) => {
diff --git a/src/core/execution/ConstructionExecution.ts b/src/core/execution/ConstructionExecution.ts
index a7e708e43..5e0f8b1b0 100644
--- a/src/core/execution/ConstructionExecution.ts
+++ b/src/core/execution/ConstructionExecution.ts
@@ -18,6 +18,7 @@ import {
 } from "../game/Upgradeables";
 import { AirfieldExecution } from "./AirfieldExecution";
 import { DefensePostExecution } from "./DefensePostExecution";
+import { DoomsdayDeviceExecution } from "./DoomsdayDeviceExecution";
 import { FighterJetExecution } from "./FighterJetExecution";
 import { MirvExecution } from "./MIRVExecution";
 import { MissileSiloExecution } from "./MissileSiloExecution";
@@ -263,6 +264,9 @@ export class ConstructionExecution implements Execution {
           this.applyUpgradesIfNeeded(built, this.desiredLevel);
         }
         break;
+      case UnitType.DoomsdayDevice:
+        this.mg.addExecution(new DoomsdayDeviceExecution(player, this.tile));
+        break;
       case UnitType.Airfield:
         this.mg.addExecution(new AirfieldExecution(player, this.tile));
         break;
diff --git a/src/core/execution/DoomsdayActivationExecution.ts b/src/core/execution/DoomsdayActivationExecution.ts
new file mode 100644
index 000000000..bfd4c2acf
--- /dev/null
+++ b/src/core/execution/DoomsdayActivationExecution.ts
@@ -0,0 +1,163 @@
+import { Execution, Game, MessageType, Player, Unit } from "../game/Game";
+import { TileRef } from "../game/GameMap";
+import { PseudoRandom } from "../PseudoRandom";
+
+export class DoomsdayActivationExecution implements Execution {
+  private active = true;
+  private mg: Game;
+  private device: Unit;
+  private spreadTiles: Set<TileRef> = new Set();
+  // Radial speed in squared-distance units per tick; controls how fast the
+  // wavefront moves outward from the device. Tuned so that visually it
+  // feels like a steady expanding circle, independent of tile density.
+  private radialSpeed = 1_000; // squared-distance units per tick
+  private random: PseudoRandom;
+  // Radial expansion data
+  private sortedLandTiles: TileRef[] = [];
+  private landDistances: Uint32Array = new Uint32Array(0); // squared distances parallel to sortedLandTiles
+  private expansionIndex = 0;
+  private currentRadiusSq = 0;
+
+  constructor(
+    private player: Player,
+    device: Unit,
+    private deviceTile: TileRef,
+  ) {
+    this.device = device;
+  }
+
+  init(mg: Game, ticks: number): void {
+    this.mg = mg;
+    this.random = new PseudoRandom(ticks);
+
+    // Build land tile list & precompute squared distances once
+    const landTilesTemp: TileRef[] = [];
+    const distTemp: number[] = [];
+    this.mg.forEachTile((t) => {
+      if (this.mg.isLand(t)) {
+        landTilesTemp.push(t);
+        distTemp.push(this.mg.euclideanDistSquared(this.deviceTile, t));
+      }
+    });
+    // Create index array and sort by precomputed distance (avoids recomputing in comparator)
+    const idx = distTemp.map((_, i) => i);
+    idx.sort((a, b) => distTemp[a] - distTemp[b]);
+    // Materialize sorted arrays
+    this.sortedLandTiles = idx.map((i) => landTilesTemp[i]);
+    this.landDistances = new Uint32Array(idx.map((i) => distTemp[i]));
+
+    // Mark device tile processed immediately if land & first element
+    if (this.mg.isLand(this.deviceTile)) {
+      this.spreadTiles.add(this.deviceTile);
+      // Ensure fallout on starting tile if unowned
+      if (this.mg.hasOwner(this.deviceTile)) {
+        const owner = this.mg.owner(this.deviceTile);
+        if (owner.isPlayer()) {
+          try {
+            owner.relinquish(this.deviceTile);
+          } catch (e) {
+            // Swallow relinquish errors; they are non-fatal for gameplay.
+          }
+        }
+      }
+      try {
+        this.mg.setFallout(this.deviceTile, true);
+      } catch (e) {
+        // Swallow fallout set errors on the device tile; non-fatal.
+      }
+      this.expansionIndex = 1; // start expanding from next tile in sorted list
+    }
+
+    // Apply custom slow doomsday FX at device location (visual-only)
+    this.mg.doomsdayExplosion(this.deviceTile, 200, this.player);
+
+    // Send message to all players
+    for (const player of this.mg.players()) {
+      this.mg.displayMessage(
+        "events_display.doomsday_triggered",
+        MessageType.DOOMSDAY_DEVICE_ACTIVATED,
+        player.id(),
+        undefined,
+        { player: this.player.displayName() },
+      );
+    }
+
+    // Destroy the device
+    this.device.delete(true, this.player);
+  }
+
+  tick(ticks: number): void {
+    if (!this.active) return;
+
+    // Spread fallout until we've processed all land tiles
+    if (this.expansionIndex < this.sortedLandTiles.length) {
+      this.spreadFallout();
+    } else {
+      this.active = false;
+    }
+  }
+
+  // Radial (Euclidean) expansion with per-tile 50% probability for fallout
+  private spreadFallout(): void {
+    const startRadiusSq = this.currentRadiusSq;
+    const maxRadiusSq = startRadiusSq + this.radialSpeed;
+    let newFallout = 0;
+    while (this.expansionIndex < this.sortedLandTiles.length) {
+      const tile = this.sortedLandTiles[this.expansionIndex];
+      const distSq = this.landDistances[this.expansionIndex];
+      // Stop for this tick once we've reached tiles beyond the current
+      // radial band; they'll be processed in future ticks as the radius
+      // continues to grow.
+      if (distSq > maxRadiusSq) {
+        break;
+      }
+      this.expansionIndex++;
+      // If there are units/structures here, apply the 80% health reduction
+      // to them when the wave reaches this tile, but do NOT apply fallout
+      // on this tile itself.
+      const unitsHere = this.mg.unitsAt(tile);
+      if (unitsHere.length > 0) {
+        for (const unit of unitsHere) {
+          if (!unit.hasHealth()) continue;
+          const currentHealth = Number(unit.health());
+          if (currentHealth <= 0) continue;
+          const damage = Math.floor(currentHealth * 0.8);
+          if (damage <= 0) continue;
+          unit.modifyHealth(-damage);
+        }
+        // Skip fallout on this tile entirely to avoid double punishment.
+        continue;
+      }
+      // 50% chance for fallout first – only pay ownership costs if applying
+      if (this.random.next() >= 0.5) continue;
+      if (this.mg.hasOwner(tile)) {
+        const owner = this.mg.owner(tile);
+        if (owner.isPlayer()) {
+          try {
+            owner.relinquish(tile);
+          } catch (e) {
+            // If relinquish fails, skip fallout to avoid exception spam
+            continue;
+          }
+        }
+      }
+      try {
+        this.mg.setFallout(tile, true);
+        this.spreadTiles.add(tile);
+        newFallout++;
+      } catch {
+        // Swallow fallout set errors on individual tiles; non-fatal.
+      }
+    }
+    // Advance the wavefront radius for the next tick
+    this.currentRadiusSq = maxRadiusSq;
+  }
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return false;
+  }
+}
diff --git a/src/core/execution/DoomsdayDeviceExecution.ts b/src/core/execution/DoomsdayDeviceExecution.ts
new file mode 100644
index 000000000..acb121b06
--- /dev/null
+++ b/src/core/execution/DoomsdayDeviceExecution.ts
@@ -0,0 +1,51 @@
+import { Execution, Game, Player, Unit, UnitType } from "../game/Game";
+import { TileRef } from "../game/GameMap";
+
+export class DoomsdayDeviceExecution implements Execution {
+  private active = true;
+  private mg: Game;
+  private device: Unit | null = null;
+
+  constructor(
+    private player: Player,
+    private tile: TileRef,
+  ) {}
+
+  init(mg: Game, ticks: number): void {
+    this.mg = mg;
+  }
+
+  tick(ticks: number): void {
+    if (this.device === null) {
+      const spawn = this.player.canBuild(UnitType.DoomsdayDevice, this.tile);
+      if (spawn === false) {
+        console.warn(
+          `player ${this.player} cannot build doomsday device at ${this.tile}`,
+        );
+        this.active = false;
+        return;
+      }
+      this.device = this.player.buildUnit(UnitType.DoomsdayDevice, spawn, {});
+
+      if (this.player !== this.device.owner()) {
+        this.player = this.device.owner();
+      }
+    }
+
+    if (!this.device.isActive()) {
+      this.active = false;
+      return;
+    }
+
+    // For now, the Doomsday Device has no special effects
+    // Future functionality can be added here
+  }
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return false;
+  }
+}
diff --git a/src/core/execution/NukeExecution.ts b/src/core/execution/NukeExecution.ts
index 376df763b..7e0d2af8c 100644
--- a/src/core/execution/NukeExecution.ts
+++ b/src/core/execution/NukeExecution.ts
@@ -13,6 +13,7 @@ import { TileRef } from "../game/GameMap";
 import { ParabolaPathFinder } from "../pathfinding/PathFinding";
 import { PseudoRandom } from "../PseudoRandom";
 import { NukeType } from "../StatsSchemas";
+import { DoomsdayActivationExecution } from "./DoomsdayActivationExecution";
 import {
   attemptInterception,
   findEligibleCitiesForNuke,
@@ -263,6 +264,25 @@ export class NukeExecution implements Execution {
     );
   }
 
+  private maybeActivateDoomsdayDevice(player: Player): void {
+    // Find all doomsday devices owned by this player
+    const doomsdayDevices = player.units(UnitType.DoomsdayDevice);
+
+    if (doomsdayDevices.length > 0) {
+      // Activate the first doomsday device
+      const device = doomsdayDevices[0];
+      const deviceTile = device.tile();
+
+      // Create activation execution
+      const activation = new DoomsdayActivationExecution(
+        player,
+        device,
+        deviceTile,
+      );
+      this.mg.addExecution(activation);
+    }
+  }
+
   private detonate() {
     if (this.nuke === null) {
       throw new Error("Not initialized");
@@ -272,6 +292,20 @@ export class NukeExecution implements Execution {
     const toDestroy = this.tilesToDestroy();
     this.maybeBreakAlliances(toDestroy);
 
+    // Check for doomsday device activation
+    const playersHit = new Set<Player>();
+    for (const tile of toDestroy) {
+      const owner = this.mg.owner(tile);
+      if (owner.isPlayer()) {
+        playersHit.add(owner);
+      }
+    }
+
+    // Activate doomsday devices for players whose territory was hit
+    for (const player of playersHit) {
+      this.maybeActivateDoomsdayDevice(player);
+    }
+
     for (const tile of toDestroy) {
       const owner = this.mg.owner(tile);
       if (owner.isPlayer()) {
diff --git a/src/core/execution/NukeExecutionHelper.ts b/src/core/execution/NukeExecutionHelper.ts
index 2c848f3ce..ff5e2299d 100644
--- a/src/core/execution/NukeExecutionHelper.ts
+++ b/src/core/execution/NukeExecutionHelper.ts
@@ -48,6 +48,9 @@ export class NukeExecutionHelper {
       UnitType.Airfield,
       UnitType.Hospital,
       UnitType.Academy,
+      UnitType.Factory,
+      UnitType.ResearchLab,
+      UnitType.DoomsdayDevice,
     );
     const structureTiles = structures.map((u) => u.tile());
     const randomTiles: (TileRef | null)[] = new Array(10);
@@ -119,6 +122,10 @@ export class NukeExecutionHelper {
             return 30_000;
           case UnitType.Academy:
             return 30_000;
+          case UnitType.Factory:
+            return 25_000;
+          case UnitType.ResearchLab:
+            return 30_000;
           default:
             return 0;
         }
diff --git a/src/core/execution/ParatrooperAttackExecution.ts b/src/core/execution/ParatrooperAttackExecution.ts
index 6165b16ad..9551a142a 100644
--- a/src/core/execution/ParatrooperAttackExecution.ts
+++ b/src/core/execution/ParatrooperAttackExecution.ts
@@ -130,7 +130,7 @@ export class ParatrooperAttackExecution implements Execution {
       game.config().paratrooperMaxNumber()
     ) {
       game.displayMessage(
-        "Maximum number of active paratrooper units reached.",
+        "events_display.max_paratrooper_units_reached",
         MessageType.WARN,
         this.attacker.id(),
       );
@@ -150,9 +150,11 @@ export class ParatrooperAttackExecution implements Execution {
     this.pathFinder = new StraightPathFinder(this.mg.map());
 
     game.displayMessage(
-      `Incoming Paratrooper Attack from ${this.attacker.displayName()}`,
+      "events_display.incoming_paratrooper_attack",
       MessageType.PARATROOPER_INBOUND,
       this.targetPlayerID,
+      undefined,
+      { attackerName: this.attacker.displayName() },
     );
 
     game.stats().paratrooperAttack(this.attacker, this.troops);
diff --git a/src/core/execution/PlayerExecution.ts b/src/core/execution/PlayerExecution.ts
index 230dc5c1b..28646a2fa 100644
--- a/src/core/execution/PlayerExecution.ts
+++ b/src/core/execution/PlayerExecution.ts
@@ -277,11 +277,9 @@ export class PlayerExecution implements Execution {
     const interval = this.config.researchIntervalTicks();
     if (interval > 0 && this.mg.ticks() % interval === 0) {
       const isHuman = this.player.type() === PlayerType.Human;
-      const logEntries: Array<{ techId: string; X: number; p: number }> = [];
       for (const [techId, X] of this._researchAccum.entries()) {
         if (!Number.isFinite(X) || X <= 0) continue;
         const p = 1 - Math.exp(-k * X);
-        if (isHuman) logEntries.push({ techId, X, p });
         const roll = this.random.next();
         if (roll < p) {
           // Success: award uniform beakers between [bMin, bMax] inclusive
@@ -297,20 +295,6 @@ export class PlayerExecution implements Execution {
           }
         }
       }
-      if (isHuman && logEntries.length > 0) {
-        // Compact, readable logging for human player's innovation probabilities
-        try {
-          const tick = this.mg.ticks();
-          const summary = logEntries
-            .map((e) => `${e.techId}: p=${e.p.toFixed(4)} X=${Math.round(e.X)}`)
-            .join(", ");
-          console.log(
-            `[Research] tick=${tick} player=${this.player.displayName()} probs -> ${summary}`,
-          );
-        } catch {
-          // best-effort logging only
-        }
-      }
       // Reset accumulators after processing the cadence boundary
       this._researchAccum.clear();
     }
diff --git a/src/core/execution/UpgradeStructureExecution.ts b/src/core/execution/UpgradeStructureExecution.ts
index e651a08b2..e4b499ffa 100644
--- a/src/core/execution/UpgradeStructureExecution.ts
+++ b/src/core/execution/UpgradeStructureExecution.ts
@@ -10,7 +10,6 @@ import { NoOpExecution } from "./NoOpExecution";
 
 /**
  * Generic structure upgrade execution.
- * Supports City, Port, Hospital, and Academy upgrades.
  */
 export class UpgradeStructureExecution implements Execution {
   private mg!: GameImpl;
diff --git a/src/core/game/Game.ts b/src/core/game/Game.ts
index 6c4b4a971..a6e8612ab 100644
--- a/src/core/game/Game.ts
+++ b/src/core/game/Game.ts
@@ -167,6 +167,7 @@ export enum UnitType {
   Bomber = "Bomber",
   Paratrooper = "Paratrooper",
   FighterJet = "Fighter Jet", // Represents a Fighter Jet unit.
+  DoomsdayDevice = "Doomsday Device",
 }
 
 export enum UpgradeType {
@@ -213,6 +214,7 @@ const _structureTypes: ReadonlySet<UnitType> = new Set([
   UnitType.ResearchLab,
   UnitType.Academy,
   UnitType.Factory,
+  UnitType.DoomsdayDevice,
 ]);
 
 export function isStructureType(type: UnitType): boolean {
@@ -304,6 +306,8 @@ export interface UnitParamsMap {
   [UnitType.FighterJet]: {
     patrolTile: TileRef;
   };
+
+  [UnitType.DoomsdayDevice]: Record<string, never>;
 }
 
 // Type helper to get params type for a specific unit type
@@ -848,6 +852,7 @@ export interface Game extends GameMap {
   // Optional as it's not initialized before the end of spawn phase
   stats(): Stats;
   bomberExplosion(tile: TileRef, radius: number, owner: Player): void;
+  doomsdayExplosion(tile: TileRef, radius: number, owner: Player): void;
   conquer(newOwner: Player, tile: TileRef): void;
 }
 
@@ -931,6 +936,7 @@ export enum MessageType {
   INSURANCE_REFUND,
   WARN,
   PEACE_TIMER_BLOCKED,
+  DOOMSDAY_DEVICE_ACTIVATED,
 }
 
 // Message categories used for filtering events in the EventsDisplay
@@ -978,6 +984,7 @@ export const MESSAGE_TYPE_CATEGORIES: Record<MessageType, MessageCategory> = {
   [MessageType.RECEIVED_TROOPS_FROM_PLAYER]: MessageCategory.TRADE,
   [MessageType.CHAT]: MessageCategory.CHAT,
   [MessageType.INSURANCE_REFUND]: MessageCategory.FINANCIAL,
+  [MessageType.DOOMSDAY_DEVICE_ACTIVATED]: MessageCategory.ATTACK,
 } as const;
 
 /**
diff --git a/src/core/game/GameImpl.ts b/src/core/game/GameImpl.ts
index 4ee73d5b3..a74d81d05 100644
--- a/src/core/game/GameImpl.ts
+++ b/src/core/game/GameImpl.ts
@@ -818,6 +818,16 @@ export class GameImpl implements Game {
     });
   }
 
+  public doomsdayExplosion(tile: TileRef, radius: number, owner: Player): void {
+    // Visual-only slow FX; no localized damage (global damage already applied in execution)
+    this.addUpdate({
+      type: GameUpdateType.DoomsdayExplosion,
+      x: this.x(tile),
+      y: this.y(tile),
+      radius: radius,
+    });
+  }
+
   sendEmojiUpdate(msg: EmojiMessage): void {
     this.addUpdate({
       type: GameUpdateType.Emoji,
diff --git a/src/core/game/GameUpdates.ts b/src/core/game/GameUpdates.ts
index cc34e56de..dd6d7aecc 100644
--- a/src/core/game/GameUpdates.ts
+++ b/src/core/game/GameUpdates.ts
@@ -47,6 +47,7 @@ export enum GameUpdateType {
   AllianceExtensionPrompt,
   AllianceExtensionAccepted,
   BomberExplosion,
+  DoomsdayExplosion,
   Roads,
   CargoTrucks,
   TileOwnerChanged,
@@ -92,6 +93,7 @@ export type GameUpdate =
   | HashUpdate
   | UnitIncomingUpdate
   | BomberExplosionUpdate
+  | DoomsdayExplosionUpdate
   | RoadsUpdate
   | CargoTrucksUpdate
   | TileOwnerChangedUpdate;
@@ -103,6 +105,13 @@ export interface BomberExplosionUpdate {
   radius: number;
 }
 
+export interface DoomsdayExplosionUpdate {
+  type: GameUpdateType.DoomsdayExplosion;
+  x: number;
+  y: number;
+  radius: number; // base radius for FX; client animates slowly
+}
+
 export interface TileUpdateWrapper {
   type: GameUpdateType.Tile;
   update: TileUpdate;
diff --git a/src/core/game/PlayerImpl.ts b/src/core/game/PlayerImpl.ts
index 408d3d25f..e9673d8fc 100644
--- a/src/core/game/PlayerImpl.ts
+++ b/src/core/game/PlayerImpl.ts
@@ -1295,6 +1295,7 @@ export class PlayerImpl implements Player {
       case UnitType.Factory:
       case UnitType.Construction:
       case UnitType.Airfield:
+      case UnitType.DoomsdayDevice:
         return this.landBasedStructureSpawn(targetTile, validTiles);
       case UnitType.CargoPlane:
       case UnitType.Bomber: