diff --git a/src/_locales/en/messages.json.ts b/src/_locales/en/messages.json.ts
index 5f1d9095c..190d0b2ba 100644
--- a/src/_locales/en/messages.json.ts
+++ b/src/_locales/en/messages.json.ts
@@ -28,6 +28,9 @@ export default exportAsMessages({
   // The text of an OK button.
   okButton: "OK",
 
+  // The text that represents the user's own personal blocklist.
+  personalBlocklist: "Personal Blocklist",
+
   // The text that means one site has been blocked.
   content_singleSiteBlocked: "uBlacklist has blocked 1 site",
 
@@ -89,6 +92,18 @@ export default exportAsMessages({
   // The text of the button to activate this extension.
   popup_activateButton: "Activate",
 
+  // The title of the disclosure widget that contains the matching rules information.
+  popup_matchingRules: "Matching Rules",
+
+  // The label for the textarea that shows rules blocking the entry.
+  popup_blockingRulesLabel: "Rules blocking this entry",
+
+  // The label for the textarea that shows rules unblocking the entry.
+  popup_unblockingRulesLabel: "Rules unblocking this entry",
+
+  // The label for the textarea that shows rules highlighting the entry.
+  popup_highlightingRulesLabel: "Rules highlighting this entry",
+
   // The title of the general section.
   options_generalTitle: "General",
 
diff --git a/src/_locales/pt_BR/messages.json.ts b/src/_locales/pt_BR/messages.json.ts
index dedca9949..9d7445376 100644
--- a/src/_locales/pt_BR/messages.json.ts
+++ b/src/_locales/pt_BR/messages.json.ts
@@ -11,6 +11,7 @@ export default exportAsMessages({
     "Não autorizado. Por favor, desligue a sincronização e ligue novamente.",
   cancelButton: "Cancelar",
   okButton: "OK",
+  personalBlocklist: "Lista de Bloqueio Pessoal",
   content_singleSiteBlocked: "uBlacklist bloqueou 1 site",
   content_multipleSitesBlocked: "uBlacklist bloqueou $1 sites",
   content_showBlockedSitesLink: "Mostrar",
@@ -31,6 +32,10 @@ export default exportAsMessages({
   popup_active: "uBlacklist está ativo",
   popup_inactive: "uBlacklist está inativo",
   popup_activateButton: "Ativar",
+  popup_matchingRules: "Regras em efeito",
+  popup_blockingRulesLabel: "Regras bloqueando este resultado",
+  popup_unblockingRulesLabel: "Regras desbloqueando este resultado",
+  popup_highlightingRulesLabel: "Regras destacando este resultado",
   options_generalTitle: "Geral",
   options_blacklistLabel:
     "Sites bloqueados de aparecer nos resultados de busca do Google",
diff --git a/src/common/locales.ts b/src/common/locales.ts
index fc588ebc2..442dd8d5a 100644
--- a/src/common/locales.ts
+++ b/src/common/locales.ts
@@ -7,6 +7,7 @@ export type MessageName =
   | "unauthorizedError"
   | "cancelButton"
   | "okButton"
+  | "personalBlocklist"
   | "content_singleSiteBlocked"
   | "content_multipleSitesBlocked"
   | "content_showBlockedSitesLink"
@@ -27,6 +28,10 @@ export type MessageName =
   | "popup_active"
   | "popup_inactive"
   | "popup_activateButton"
+  | "popup_matchingRules"
+  | "popup_blockingRulesLabel"
+  | "popup_unblockingRulesLabel"
+  | "popup_highlightingRulesLabel"
   | "options_generalTitle"
   | "options_blacklistLabel"
   | "options_blacklistHelper"
diff --git a/src/scripts/block-dialog.tsx b/src/scripts/block-dialog.tsx
index 8715bd1da..2f61ec6d5 100644
--- a/src/scripts/block-dialog.tsx
+++ b/src/scripts/block-dialog.tsx
@@ -30,8 +30,8 @@ import type { InteractiveRuleset } from "./interactive-ruleset.ts";
 import { translate } from "./locales.ts";
 import { PathDepth } from "./path-depth.ts";
 import type { LinkProps } from "./ruleset/ruleset.ts";
-import type { DialogTheme } from "./types.ts";
-import { makeAltURL, svgToDataURL } from "./utilities.ts";
+import type { DialogTheme, MatchingRulesText } from "./types.ts";
+import { getMatchingRulesText, makeAltURL, svgToDataURL } from "./utilities.ts";
 
 type BlockDialogContentProps = {
   blockWholeSite: boolean;
@@ -59,6 +59,8 @@ const BlockDialogContent: React.FC<BlockDialogContentProps> = ({
     unblock: false,
     host: "",
     detailsOpen: false,
+    matchingRulesOpen: false,
+    matchingRulesText: null as MatchingRulesText | null,
     pathDepth: null as PathDepth | null,
     depth: "",
     rulesToAdd: "",
@@ -76,6 +78,8 @@ const BlockDialogContent: React.FC<BlockDialogContentProps> = ({
         blockWholeSite ? tldts.getDomain(url.host) ?? url.host : url.host,
       );
       state.detailsOpen = false;
+      state.matchingRulesOpen = false;
+      state.matchingRulesText = null;
       state.pathDepth = enablePathDepth ? new PathDepth(url) : null;
       state.depth = "0";
       state.rulesToAdd = patch.rulesToAdd;
@@ -86,6 +90,8 @@ const BlockDialogContent: React.FC<BlockDialogContentProps> = ({
       state.unblock = false;
       state.host = entryProps.url;
       state.detailsOpen = false;
+      state.matchingRulesOpen = false;
+      state.matchingRulesText = null;
       state.pathDepth = null;
       state.depth = "";
       state.rulesToAdd = "";
@@ -269,6 +275,89 @@ const BlockDialogContent: React.FC<BlockDialogContentProps> = ({
                 </Row>
               </DetailsBody>
             </Details>
+            <Details
+              open={state.matchingRulesOpen}
+              onToggle={(e) => {
+                const { open } = e.currentTarget;
+                const matchingRulesText = open
+                  ? getMatchingRulesText(ruleset, entryProps)
+                  : null;
+                setState((s) => ({
+                  ...s,
+                  matchingRulesOpen: open,
+                  matchingRulesText,
+                }));
+              }}
+            >
+              <DetailsSummary className={FOCUS_START_CLASS}>
+                {translate("popup_matchingRules")}
+              </DetailsSummary>
+              <DetailsBody>
+                <Row>
+                  <RowItem expanded>
+                    <LabelWrapper fullWidth>
+                      <ControlLabel for="blocking-rules-text">
+                        {translate("popup_blockingRulesLabel")}
+                      </ControlLabel>
+                    </LabelWrapper>
+                    {state.matchingRulesOpen && (
+                      <TextArea
+                        breakAll
+                        id="blocking-rules-text"
+                        readOnly
+                        monospace
+                        nowrap
+                        rows={4}
+                        resizable
+                        value={state.matchingRulesText?.blockRules}
+                      />
+                    )}
+                  </RowItem>
+                </Row>
+                <Row>
+                  <RowItem expanded>
+                    <LabelWrapper fullWidth>
+                      <ControlLabel for="unblocking-rules-text">
+                        {translate("popup_unblockingRulesLabel")}
+                      </ControlLabel>
+                    </LabelWrapper>
+                    {state.matchingRulesOpen && (
+                      <TextArea
+                        breakAll
+                        id="unblocking-rules-text"
+                        readOnly
+                        monospace
+                        nowrap
+                        rows={4}
+                        resizable
+                        value={state.matchingRulesText?.unblockRules}
+                      />
+                    )}
+                  </RowItem>
+                </Row>
+                <Row>
+                  <RowItem expanded>
+                    <LabelWrapper fullWidth>
+                      <ControlLabel for="highlight-rules-text">
+                        {translate("popup_highlightingRulesLabel")}
+                      </ControlLabel>
+                    </LabelWrapper>
+                    {state.matchingRulesOpen && (
+                      <TextArea
+                        breakAll
+                        id="highlight-rules-text"
+                        readOnly
+                        monospace
+                        nowrap
+                        rows={4}
+                        resizable
+                        value={state.matchingRulesText?.highlightRules}
+                      />
+                    )}
+                  </RowItem>
+                </Row>
+              </DetailsBody>
+            </Details>
           </RowItem>
         </Row>
       </DialogBody>
diff --git a/src/scripts/components/details.tsx b/src/scripts/components/details.tsx
index 873d139ae..d07012e82 100644
--- a/src/scripts/components/details.tsx
+++ b/src/scripts/components/details.tsx
@@ -6,7 +6,18 @@ export type DetailsProps = JSX.IntrinsicElements["details"];
 
 export const Details = React.forwardRef<HTMLDetailsElement, DetailsProps>(
   function Details(props, ref) {
-    return <details {...props} ref={ref} />;
+    const className = useClassName(
+      () => ({
+        "&:not(:first-of-type)": {
+          marginTop: "0.5em",
+        },
+        "&:is(details[open] + &)": {
+          marginTop: "1em",
+        },
+      }),
+      [],
+    );
+    return <details {...applyClassName(props, className)} ref={ref} />;
   },
 );
 
diff --git a/src/scripts/components/textarea.tsx b/src/scripts/components/textarea.tsx
index 697575039..bc832efa6 100644
--- a/src/scripts/components/textarea.tsx
+++ b/src/scripts/components/textarea.tsx
@@ -5,10 +5,22 @@ import { useClassName } from "./utilities.ts";
 
 export type TextAreaProps = JSX.IntrinsicElements["textarea"] & {
   breakAll?: boolean;
+  resizable?: boolean;
+  monospace?: boolean;
+  nowrap?: boolean;
 };
 
 export const TextArea = React.forwardRef<HTMLTextAreaElement, TextAreaProps>(
-  function TextArea({ breakAll = false, ...props }, ref) {
+  function TextArea(
+    {
+      breakAll = false,
+      resizable = false,
+      monospace = false,
+      nowrap = false,
+      ...props
+    },
+    ref,
+  ) {
     const className = useClassName(
       (theme) => ({
         background: "transparent",
@@ -22,8 +34,10 @@ export const TextArea = React.forwardRef<HTMLTextAreaElement, TextAreaProps>(
             ? `calc(1.5em * ${props.rows} + 1em + 2px)`
             : "auto",
         lineHeight: "1.5",
+        fontFamily: monospace ? "monospace" : "inherit",
+        textWrap: nowrap ? "nowrap" : "wrap",
         padding: "0.5em 0.625em",
-        resize: "none",
+        resize: resizable ? "vertical" : "none",
         width: "100%",
         wordBreak: breakAll ? "break-all" : "normal",
         "&:disabled": {
diff --git a/src/scripts/content-script.tsx b/src/scripts/content-script.tsx
index 5dfedb5aa..776dc6e80 100644
--- a/src/scripts/content-script.tsx
+++ b/src/scripts/content-script.tsx
@@ -189,9 +189,10 @@ class ContentScript {
           fromPlainRuleset(options.ruleset || null, options.blacklist),
           Object.values(options.subscriptions)
             .filter((subscription) => subscription.enabled ?? true)
-            .map(({ ruleset, blacklist }) =>
-              fromPlainRuleset(ruleset || null, blacklist),
-            ),
+            .map(({ ruleset, blacklist, name }) => ({
+              name,
+              ruleset: fromPlainRuleset(ruleset || null, blacklist),
+            })),
         ),
         skipBlockDialog: options.skipBlockDialog,
         hideControls: options.hideControl,
diff --git a/src/scripts/interactive-ruleset.test.ts b/src/scripts/interactive-ruleset.test.ts
index ed4dc5fb3..862dbe232 100644
--- a/src/scripts/interactive-ruleset.test.ts
+++ b/src/scripts/interactive-ruleset.test.ts
@@ -9,7 +9,10 @@ function createInteractiveRuleset(
 ): InteractiveRuleset {
   return new InteractiveRuleset(
     new Ruleset(user),
-    subscriptions.map((subscription) => new Ruleset(subscription)),
+    subscriptions.map((subscription, index) => ({
+      name: String(index),
+      ruleset: new Ruleset(subscription),
+    })),
   );
 }
 
diff --git a/src/scripts/interactive-ruleset.ts b/src/scripts/interactive-ruleset.ts
index 00deece8e..5fa7f9f67 100644
--- a/src/scripts/interactive-ruleset.ts
+++ b/src/scripts/interactive-ruleset.ts
@@ -67,14 +67,41 @@ export type Patch = {
   lineNumbersToRemove: number[];
 };
 
+export type SubscriptionRuleset = {
+  name: string;
+  ruleset: Ruleset;
+};
+
+type MatchingRule = {
+  lineNumber: number;
+  lineContent: string | null;
+};
+
+export type RulesetMatches = {
+  rulesetName: string;
+  blockRules: MatchingRule[];
+  unblockRules: MatchingRule[];
+  highlightRules: MatchingRule[];
+};
+
 export class InteractiveRuleset {
   private readonly userRuleset: Ruleset;
   private readonly subscriptionRulesets: readonly Ruleset[];
+  private readonly subscriptionNames: WeakMap<Ruleset, string>;
   private patch: Patch | null = null;
 
-  constructor(userRuleset: Ruleset, subscriptionRulesets: readonly Ruleset[]) {
+  constructor(
+    userRuleset: Ruleset,
+    subscriptionRulesets: SubscriptionRuleset[],
+  ) {
     this.userRuleset = userRuleset;
-    this.subscriptionRulesets = subscriptionRulesets;
+    this.subscriptionRulesets = subscriptionRulesets.map(
+      ({ ruleset }) => ruleset,
+    );
+    this.subscriptionNames = new WeakMap();
+    for (const { name, ruleset } of subscriptionRulesets) {
+      this.subscriptionNames.set(ruleset, name);
+    }
   }
 
   toString(): string {
@@ -253,6 +280,33 @@ export class InteractiveRuleset {
   deletePatch(): void {
     this.patch = null;
   }
+
+  getMatchingRules(props: Readonly<LinkProps>): RulesetMatches[] {
+    const results: RulesetMatches[] = [];
+    // Get rules from user's personal blacklist
+    const matches = getMatchesPerRuleset(
+      "personal-blocklist",
+      this.userRuleset,
+      props,
+    );
+    if (matches) {
+      results.push(matches);
+    }
+
+    // Get matching rules from subscription lists
+    for (const subscriptionRuleset of this.subscriptionRulesets) {
+      const subscriptionMatches = getMatchesPerRuleset(
+        // biome-ignore lint/style/noNonNullAssertion: Subscriptions always have names
+        this.subscriptionNames.get(subscriptionRuleset)!,
+        subscriptionRuleset,
+        props,
+      );
+      if (subscriptionMatches) {
+        results.push(subscriptionMatches);
+      }
+    }
+    return results;
+  }
 }
 
 function suggestMatchPattern(
@@ -269,3 +323,72 @@ function suggestMatchPattern(
   }
   return `${unblock ? "@" : ""}*://${host}/*`;
 }
+
+function getMatchesPerRuleset(
+  rulesetName: Readonly<string>,
+  ruleset: Ruleset,
+  props: Readonly<LinkProps>,
+): RulesetMatches | null {
+  const matches: RulesetMatches = {
+    rulesetName,
+    blockRules: [],
+    unblockRules: [],
+    highlightRules: [],
+  };
+
+  const rawResults = testRawWithURLParts(ruleset, props);
+
+  // Iterate through the latest version of the user ruleset.
+  // This is necessary because, unlike subscription rulesets, the user
+  // can make multiple alterations to the personal blacklist using the
+  // "Block this website" button.
+  // This ensures the line numbers are accurate without reloading.
+  const rulesetLines =
+    rulesetName === "personal-blocklist" ? [...ruleset] : null;
+  const previousMatchIndexes = new Map<string, number>();
+
+  for (let { lineNumber, specifier } of rawResults) {
+    const lineContent = ruleset.get(lineNumber);
+    if (lineContent && rulesetLines) {
+      lineNumber = getAccurateLineNumber(
+        lineContent,
+        rulesetLines,
+        previousMatchIndexes.get(lineContent),
+      );
+      if (lineNumber === -1) {
+        continue;
+      }
+      // Save the last line number for a particular rule in order to
+      // accurately spot repeated rules (two or more equal lines).
+      previousMatchIndexes.set(lineContent, lineNumber);
+    }
+
+    const rule: MatchingRule = {
+      lineNumber,
+      lineContent,
+    };
+    if (!specifier) {
+      matches.blockRules.push(rule);
+    } else if (specifier.type === "negate") {
+      matches.unblockRules.push(rule);
+    } else if (specifier.type === "highlight") {
+      matches.highlightRules.push(rule);
+    }
+  }
+  if (
+    Object.values(matches)
+      .filter((prop) => Array.isArray(prop))
+      .every((arr) => arr.length === 0)
+  ) {
+    return null;
+  }
+  return matches;
+}
+
+function getAccurateLineNumber(
+  lineContent: string,
+  lines: string[],
+  previousLineNumber = 0,
+): number {
+  return lines.indexOf(lineContent, previousLineNumber) + 1;
+}
diff --git a/src/scripts/popup.tsx b/src/scripts/popup.tsx
index 08ee33a74..ac6ee7f24 100644
--- a/src/scripts/popup.tsx
+++ b/src/scripts/popup.tsx
@@ -200,9 +200,10 @@ const Popup: React.FC = () => {
           fromPlainRuleset(options.ruleset || null, options.blacklist),
           Object.values(options.subscriptions)
             .filter((subscription) => subscription.enabled ?? true)
-            .map(({ ruleset, blacklist }) =>
-              fromPlainRuleset(ruleset || null, blacklist),
-            ),
+            .map(({ ruleset, blacklist, name }) => ({
+              name,
+              ruleset: fromPlainRuleset(ruleset || null, blacklist),
+            })),
         );
         setState({
           type: "block",
diff --git a/src/scripts/types.ts b/src/scripts/types.ts
index 9de43cdd4..3a00e99e4 100644
--- a/src/scripts/types.ts
+++ b/src/scripts/types.ts
@@ -1,7 +1,7 @@
 import type dayjs from "dayjs";
 import type { MessageName0 } from "../common/locales.ts";
 import type { SearchEngine as _SearchEngine } from "../common/search-engines.ts";
-import type { QueryResult } from "./interactive-ruleset.ts";
+import type { QueryResult, RulesetMatches } from "./interactive-ruleset.ts";
 import type { LinkProps } from "./ruleset/ruleset.ts";
 
 export type {
@@ -205,3 +205,11 @@ export type Subscription = {
 
 export type Subscriptions = Record<SubscriptionId, Subscription>;
 // #endregion Subscriptions
+
+// #region MatchingRules
+
+export type MatchingRuleKind = keyof Omit<RulesetMatches, "rulesetName">;
+
+export type MatchingRulesText = Record<MatchingRuleKind, string>;
+
+// #endregion MatchingRules
diff --git a/src/scripts/utilities.ts b/src/scripts/utilities.ts
index d57bd70db..03d7f2a57 100644
--- a/src/scripts/utilities.ts
+++ b/src/scripts/utilities.ts
@@ -1,7 +1,15 @@
 import dayjs from "dayjs";
-import { Ruleset, type RulesetJSON } from "./ruleset/ruleset.ts";
+import type { InteractiveRuleset } from "./interactive-ruleset.ts";
+import { translate } from "./locales.ts";
+import {
+  type LinkProps,
+  Ruleset,
+  type RulesetJSON,
+} from "./ruleset/ruleset.ts";
 import type {
   ErrorResult,
+  MatchingRuleKind,
+  MatchingRulesText,
   PlainRuleset,
   Result,
   SuccessResult,
@@ -140,6 +148,63 @@ export function numberEntries<Key extends number, Value>(
 export function lines(s: string): string[] {
   return s ? s.split("\n") : [];
 }
+
+export function getMatchingRulesText(
+  ruleset: InteractiveRuleset,
+  props: LinkProps,
+): MatchingRulesText {
+  const ruleTypes: MatchingRuleKind[] = [
+    "blockRules",
+    "unblockRules",
+    "highlightRules",
+  ];
+  const matchingRulesText: MatchingRulesText = {
+    blockRules: "",
+    unblockRules: "",
+    highlightRules: "",
+  };
+
+  const matchingRules = ruleset.getMatchingRules(props);
+  const biggestLineNumber = Math.max(
+    ...matchingRules
+      .flatMap(({ blockRules, unblockRules, highlightRules }) => [
+        ...blockRules,
+        ...unblockRules,
+        ...highlightRules,
+      ])
+      .map(({ lineNumber }) => lineNumber),
+  );
+  const lineNumberLength = String(biggestLineNumber).length;
+
+  for (const ruleType of ruleTypes) {
+    for (const match of matchingRules) {
+      // Check whether the ruleset contains rules of the current rule type
+      if (match[ruleType].length === 0) continue;
+      // Add header with ruleset name
+      const headerContent =
+        match.rulesetName === "personal-blocklist"
+          ? translate("personalBlocklist")
+          : match.rulesetName;
+      matchingRulesText[ruleType] += `# ${headerContent}\n`;
+      // Add individual rules
+      matchingRulesText[ruleType] += match[ruleType]
+        .map(({ lineContent, lineNumber }) => {
+          const lineNumberStr = String(lineNumber);
+          const formattedLineNumber =
+            lineNumberStr.length < lineNumberLength
+              ? // Add left padding in order to align all line numbers
+                " ".repeat(lineNumberLength - lineNumberStr.length) + lineNumber
+              : lineNumberStr;
+          return `${formattedLineNumber}: ${lineContent}`;
+        })
+        .join("\n");
+      matchingRulesText[ruleType] += "\n";
+    }
+  }
+
+  return matchingRulesText;
+}
+
 // #endregion string
 
 export function downloadTextFile(