diff --git a/src/encounter/ui/Encounter.svelte b/src/encounter/ui/Encounter.svelte
index 3f7ff4ae..da349d2d 100644
--- a/src/encounter/ui/Encounter.svelte
+++ b/src/encounter/ui/Encounter.svelte
@@ -273,6 +273,9 @@
     .easy .difficulty-label {
         color: green;
     }
+    .trivial .difficulty-label {
+        color: #AAAAAA;
+    }
     .icons {
         display: flex;
     }
diff --git a/src/encounter/ui/EncounterRow.svelte b/src/encounter/ui/EncounterRow.svelte
index 222da673..bfcb559c 100644
--- a/src/encounter/ui/EncounterRow.svelte
+++ b/src/encounter/ui/EncounterRow.svelte
@@ -221,6 +221,9 @@
     .easy .difficulty-label {
         color: green;
     }
+    .trivial .difficulty-label {
+        color: #AAAAAA;
+    }
     .icons {
         display: flex;
     }
diff --git a/src/tracker/ui/Difficulty.svelte b/src/tracker/ui/Difficulty.svelte
index cb1be4cd..cc21d9fd 100644
--- a/src/tracker/ui/Difficulty.svelte
+++ b/src/tracker/ui/Difficulty.svelte
@@ -2,6 +2,8 @@
     import { tweened } from "svelte/motion";
     import { cubicOut } from "svelte/easing";
     import { getContext } from "svelte";
+    import { getRpgSystem } from "src/utils"
+    import type { RpgSystem } from "src/utils/rpg-system/rpgSystem";
     import type InitiativeTracker from "src/main";
 
     import { tracker } from "../stores/tracker";
@@ -11,6 +13,8 @@
 
     const dif = difficulty(plugin);
 
+    const rpgSystem: RpgSystem = getRpgSystem(plugin);
+
     const difficultyBar = tweened(0, {
         duration: 400,
         easing: cubicOut
@@ -26,7 +30,7 @@
 </script>
 
 <div class="difficulty-bar-container" aria-label={summary}>
-    <span>Easy</span>
+    <span>{rpgSystem.SystemDifficulties[0]}</span>
     <span
         ><meter
             class="difficulty-bar"
@@ -37,7 +41,7 @@
             value={$difficultyBar}
         /></span
     >
-    <span>Deadly</span>
+    <span>{rpgSystem.SystemDifficulties.slice(-1)}</span>
 </div>
 
 <style>
diff --git a/src/utils/rpg-system/dnd5e-lazygm.ts b/src/utils/rpg-system/dnd5e-lazygm.ts
index 23a5d89d..dad23cfb 100644
--- a/src/utils/rpg-system/dnd5e-lazygm.ts
+++ b/src/utils/rpg-system/dnd5e-lazygm.ts
@@ -13,6 +13,11 @@ export class Dnd5eLazyGmRpgSystem extends RpgSystem {
     plugin: InitiativeTracker;
     dnd5eRpgSystem: Dnd5eRpgSystem;
 
+    override systemDifficulties: [string, string, ...string[]] = [
+		"Not Deadly",
+		"Deadly"
+	]
+
     constructor(plugin: InitiativeTracker) {
         super();
         this.plugin = plugin;
diff --git a/src/utils/rpg-system/dnd5e.ts b/src/utils/rpg-system/dnd5e.ts
index 08a210a4..ae5e4396 100644
--- a/src/utils/rpg-system/dnd5e.ts
+++ b/src/utils/rpg-system/dnd5e.ts
@@ -69,6 +69,13 @@ const XP_PER_CR: Record<string, number> = {
 export class Dnd5eRpgSystem extends RpgSystem {
   plugin: InitiativeTracker;
 
+  override systemDifficulties: [string, string, ...string[]] = [
+		"Easy",
+		"Medium",
+		"Hard",
+		"Deadly"
+	]
+
   constructor(plugin: InitiativeTracker) {
     super();
     this.plugin = plugin;
diff --git a/src/utils/rpg-system/index.ts b/src/utils/rpg-system/index.ts
index 09c5d827..30c4ead0 100644
--- a/src/utils/rpg-system/index.ts
+++ b/src/utils/rpg-system/index.ts
@@ -3,14 +3,18 @@ import type { SRDMonster } from "../../../index";
 import type InitiativeTracker from "../../main";
 import { Dnd5eRpgSystem } from "./dnd5e";
 import { Dnd5eLazyGmRpgSystem } from "./dnd5e-lazygm";
+import { Pathfinder2eRpgSystem } from "./pf2e"
 import { RpgSystem } from "./rpgSystem";
+import { DEFAULT_UNDEFINED } from "../constants";
 
 export type GenericCreature = Creature | SRDMonster;
 
 export type DifficultyLevel = {
   /** Name of the difficulty level, eg "trivial". Used to display the difficulty level in encounters. */
   displayName: string,
-  /** The CSS class to apply when formatting the display name. */
+  /** The CSS class to apply when formatting the display name. Should map to DnD 5e thresholds (low, easy, medium, hard, extreme) + trivial
+   *  so systems do not have have their own custom styling.
+   */
   cssClass: string,
   /** Associated value for the difficulty level. This should be the value used to calculate the difficulty level. */
   value: number,
@@ -49,11 +53,14 @@ export type IntermediateValues = { label: string, value: number }[]
 
 export enum RpgSystemSetting {
   Dnd5e = "dnd5e",
-  Dnd5eLazyGm = "dnd5e-lazygm"
+  Dnd5eLazyGm = "dnd5e-lazygm",
+  Pathfinder2e = "pathfinder2e"
 }
 
 
-class UndefinedRpgSystem extends RpgSystem {}
+class UndefinedRpgSystem extends RpgSystem {
+  systemDifficulties: [string, string, ...string[]] = [DEFAULT_UNDEFINED, DEFAULT_UNDEFINED];
+}
 
 /**
  * Returns the RpgSystem associated with the settings value. If not provided,
@@ -63,6 +70,7 @@ export function getRpgSystem(plugin: InitiativeTracker, settingId?: string): Rpg
   switch (settingId ? settingId : plugin.data.rpgSystem) {
     case RpgSystemSetting.Dnd5e: return new Dnd5eRpgSystem(plugin);
     case RpgSystemSetting.Dnd5eLazyGm: return new Dnd5eLazyGmRpgSystem(plugin);
+    case RpgSystemSetting.Pathfinder2e: return new Pathfinder2eRpgSystem(plugin);
   }
   return new UndefinedRpgSystem();
 }
\ No newline at end of file
diff --git a/src/utils/rpg-system/pf2e.ts b/src/utils/rpg-system/pf2e.ts
new file mode 100644
index 00000000..611fd407
--- /dev/null
+++ b/src/utils/rpg-system/pf2e.ts
@@ -0,0 +1,135 @@
+import { RpgSystem } from './rpgSystem'
+import { crToString, getFromCreatureOrBestiary } from '..'
+import type { DifficultyLevel, GenericCreature, DifficultyThreshold } from '.'
+import type InitiativeTracker from '../../main'
+
+// level without proficiency variant
+// const xpVariantCreatureDifferences = new Map([
+//   [-7, 9],
+//   [-6, 12],
+//   [-5, 14],
+//   [-4, 18],
+//   [-3, 21],
+//   [-2, 26],
+//   [-1, 32],
+//   [0, 40],
+//   [1, 48],
+//   [2, 60],
+//   [3, 72],
+//   [4, 90],
+//   [5, 108],
+//   [6, 135],
+//   [7, 160],
+// ]);
+
+const XP_CREATURE_DIFFERENCES: Record<string, number> = {
+	'-4': 10,
+	'-3': 15,
+	'-2': 20,
+	'-1': 30,
+	'0': 40,
+	'1': 60,
+	'2': 80,
+	'3': 120,
+	'4': 160,
+}
+
+const XP_SIMPLE_HAZARD_DIFFERENCES: Record<string, number> = {
+	'-4': 2,
+	'-3': 3,
+	'-2': 4,
+	'-1': 6,
+	'0': 8,
+	'1': 12,
+	'2': 16,
+	'3': 24,
+	'4': 32,
+}
+
+const PF2E_DND5E_DIFFICULTY_MAPPING: Record<string, string> = {
+	'trivial': 'trivial',
+	'low': 'easy',
+	'moderate': 'medium',
+	'severe': 'hard',
+	'extreme': 'deadly'
+}
+
+export class Pathfinder2eRpgSystem extends RpgSystem {	
+	plugin: InitiativeTracker
+
+	override systemDifficulties: [string, string, ...string[]] = [
+		"Trivial",
+		"Low",
+		"Moderate",
+		"Severe",
+		"Extreme"
+	]
+
+	constructor(plugin: InitiativeTracker) {
+		super()
+		this.plugin = plugin
+		this.displayName = 'Pathfinder 2e'
+	}
+
+	getCreatureDifficulty(
+		creature: GenericCreature,
+		playerLevels?: number[]
+	): number {
+		const lvl = getFromCreatureOrBestiary(
+			this.plugin,
+			creature,
+			(c) => c?.level
+		)?.toString().split(' ').slice(-1)
+		if (lvl == null || lvl == undefined) return 0
+		const partyLvl = playerLevels?.length ?? 0 > 0 ?  playerLevels.reduce((a, b) => a + b) / playerLevels.length : 0
+
+		const creature_differences = String(
+			lvl - partyLvl
+		)
+
+		return XP_CREATURE_DIFFERENCES[creature_differences] ?? 0
+	}
+
+	getDifficultyThresholds(playerLevels: number[]): DifficultyThreshold[] {
+		const budget = playerLevels.length * 20
+		const encounterBudget: Record<string, number> = {
+			trivial: Math.floor(budget * 0.5),
+			low: Math.floor(budget * 0.75),
+			moderate: budget,
+			severe: Math.floor(budget * 1.5),
+			extreme: Math.floor(budget * 2),
+		}
+		return Object.entries(encounterBudget).map(([name, value]) => ({
+			displayName: name.charAt(0).toUpperCase() + name.slice(1),
+			minValue: value
+		})).sort((a, b) => a.minValue - b.minValue)
+	}
+
+	getEncounterDifficulty(
+		creatures: Map<GenericCreature, number>,
+		playerLevels: number[]
+	): DifficultyLevel {
+		const creatureXp = [...creatures].reduce(
+			(acc, [creature, count]) =>
+				acc + this.getCreatureDifficulty(creature, playerLevels) * count,
+			0
+		)
+
+		const thresholds = this.getDifficultyThresholds(playerLevels)
+		const displayName = thresholds.find(threshold => creatureXp <= threshold.minValue)?.displayName ?? "Trivial"
+		const thresholdSummary = thresholds.map((threshold) => `${threshold.displayName}: ${threshold.minValue}`).join('\n')
+		const summary = `Encounter is ${displayName}
+    Total XP: ${creatureXp}
+    Threshold
+    ${thresholdSummary}`;
+
+		return {
+			displayName,
+			summary,
+			cssClass: PF2E_DND5E_DIFFICULTY_MAPPING[displayName.toLowerCase()] ?? "trivial",
+			value: creatureXp,
+			title: "Total XP",
+			intermediateValues: [{ label: "Total XP", value: creatureXp }],
+		};
+	}
+}
diff --git a/src/utils/rpg-system/rpgSystem.ts b/src/utils/rpg-system/rpgSystem.ts
index bc7f4e3c..bd7e51ff 100644
--- a/src/utils/rpg-system/rpgSystem.ts
+++ b/src/utils/rpg-system/rpgSystem.ts
@@ -2,6 +2,8 @@ import { DEFAULT_UNDEFINED } from "../constants";
 import type { GenericCreature, DifficultyLevel, DifficultyThreshold } from "./index";
 
 export abstract class RpgSystem {
+  abstract systemDifficulties: [string, string, ...string[]];
+
   /** The display name of the RPG system, used in the UI. */
   displayName: string = DEFAULT_UNDEFINED;