diff --git a/packages/bundlesize/README.md b/packages/bundlesize/README.md
index 6267a182..d928a6fd 100644
--- a/packages/bundlesize/README.md
+++ b/packages/bundlesize/README.md
@@ -413,6 +413,37 @@ Notes:
 }
 ```
 
+### Compare sizes measured by another tool against a baseline
+
+`--type compare` needs no configuration file. It reads a sizes file in the shape `size-limit --json` prints, an array of `{ name, size, sizeLimit?, passed? }` with sizes in bytes, and renders a markdown table with a "vs main" column showing each change in kB and percent:
+
+```sh
+> size-limit --json > tmp/sizes.json || true
+> bundlesize --type compare --current tmp/sizes.json --baseline tmp/baseline/sizes.json --base-sha "$BASE_SHA" --kilo 1000 --silent -o tmp/pr-stats.md
+```
+
+| Status | Section     | Size (gzip) | vs main             | Limit (gzip) |
+| ------ | ----------- | ----------- | ------------------- | ------------ |
+| ✅     | first-paint | 150.43 kB   | ▼ −717 B (−0.47%)   | 153 kB       |
+
+`size-limit` exits 1 when a limit is exceeded, which is exactly when the report matters, hence the `|| true`: let `compare` own the exit code. A missing `--baseline` file is not an error: the table shows `n/a` and a note says no baseline was found. An unreadable or malformed one is treated the same way, with a warning, so a broken artifact on main cannot fail every pull request. Entries in the baseline that are gone from this run are listed as removed. Entry names must be unique, so give each size-limit check its own `name`. Other flags:
+
+- `--header`: markdown heading above the table (default `## Bundle Size`).
+- `--footer`: markdown appended after the table. Pass it as `--footer="..."`: a value starting with `-`, such as a list item, is otherwise read as a flag.
+- `--base-ref`: branch the baseline was measured on (default `main`).
+- `--base-sha`: commit the baseline was measured on, shown in the note. Pass the commit of the run that produced the baseline file, which is not always the pull request's base commit.
+- `--kilo` (required): bytes per kB, `1000` for size-limit's units or `1024` for rsbuild's.
+- `--threshold`: changes under this many bytes are shown as no change.
+- `--silent`: exit 0 even when an entry is over its limit.
+
+The same renderer is exported for scripts that measure sizes themselves:
+
+```js
+import { compareSizes } from "@node-cli/bundlesize";
+
+const { data, passed } = compareSizes({ current, baseline, baseSha });
+```
+
 ## Get help
 
 ```sh
diff --git a/packages/bundlesize/bundlesize.config.js b/packages/bundlesize/bundlesize.config.js
index 28d5cc55..3be0ddd7 100644
--- a/packages/bundlesize/bundlesize.config.js
+++ b/packages/bundlesize/bundlesize.config.js
@@ -14,5 +14,13 @@ export default {
 			path: "dist/parse.js",
 			limit: "1.5 kB",
 		},
+		{
+			path: "dist/compare.js",
+			limit: "2 kB",
+		},
+		{
+			path: "dist/compareStats.js",
+			limit: "2 kB",
+		},
 	],
 };
diff --git a/packages/bundlesize/src/__tests__/cli.test.ts b/packages/bundlesize/src/__tests__/cli.test.ts
new file mode 100644
index 00000000..7fb3f60e
--- /dev/null
+++ b/packages/bundlesize/src/__tests__/cli.test.ts
@@ -0,0 +1,71 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { compareStats } from "../compareStats.js";
+import { getOutputFile } from "../utilities.js";
+
+const originalArgv = process.argv;
+
+afterEach(() => {
+	process.argv = originalArgv;
+	vi.resetModules();
+});
+
+/**
+ * Parse argv with the real CLI flag definitions, so a renamed flag in parse.ts
+ * breaks this test instead of silently breaking the documented CLI.
+ */
+const parseFlags = async (argv: string[]) => {
+	process.argv = ["node", "bundlesize", ...argv];
+	vi.resetModules();
+	const { config } = await import("../parse.js");
+	return config.flags;
+};
+
+describe("compare CLI flags", () => {
+	it("maps the documented kebab-case flags into a working compare run", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "bundlesize-cli-"));
+		try {
+			const current = join(dir, "current.json");
+			const baseline = join(dir, "baseline.json");
+			writeFileSync(current, JSON.stringify([{ name: "a", size: 2000 }]));
+			writeFileSync(baseline, JSON.stringify([{ name: "a", size: 1000 }]));
+			const flags = await parseFlags([
+				"--type",
+				"compare",
+				"--current",
+				current,
+				"--baseline",
+				baseline,
+				"--base-ref",
+				"trunk",
+				"--base-sha",
+				"abc1234",
+				"--kilo",
+				"1000",
+				"--threshold",
+				"5",
+				"--footer=- see docs",
+				"-o",
+				join(dir, "out.md"),
+			]);
+			expect(flags.type).toBe("compare");
+			const result = compareStats({ flags });
+			expect(result.exitCode).toBe(0);
+			expect(result.outputFile).toBe(join(dir, "out.md"));
+			expect(result.data).toContain("| vs trunk |");
+			expect(result.data).toContain("| ▲ +1 kB (+100.00%) |");
+			expect(result.data).toContain("Compared with `trunk` @ `abc1234`.");
+			expect(result.data).toContain("- see docs");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("getOutputFile", () => {
+	it("keeps an absolute output path as is", () => {
+		expect(getOutputFile("/tmp/report.md")).toBe("/tmp/report.md");
+	});
+});
diff --git a/packages/bundlesize/src/__tests__/compare.test.ts b/packages/bundlesize/src/__tests__/compare.test.ts
new file mode 100644
index 00000000..2090257d
--- /dev/null
+++ b/packages/bundlesize/src/__tests__/compare.test.ts
@@ -0,0 +1,244 @@
+import { describe, expect, it } from "vitest";
+import { compareSizes, formatDelta, formatSize } from "../compare.js";
+
+describe("formatSize", () => {
+	it("uses the kilo base it is given", () => {
+		expect(formatSize(153000, 1000)).toBe("153 kB");
+		expect(formatSize(268288, 1024)).toBe("262 kB");
+		expect(formatSize(266076, 1024)).toBe("259.84 kB");
+	});
+
+	it("never prints an undefined unit or a whole next unit", () => {
+		expect(formatSize(0.5, 1024)).toBe("0.5 B");
+		expect(formatSize(1048575, 1024)).toBe("1 MB");
+		expect(formatSize(999999, 1000)).toBe("1 MB");
+		expect(formatSize(1023.999, 1024)).toBe("1 kB");
+	});
+
+	it("handles zero, bytes and megabytes", () => {
+		expect(formatSize(0, 1024)).toBe("0 B");
+		expect(formatSize(512, 1024)).toBe("512 B");
+		expect(formatSize(1402880, 1024)).toBe("1.34 MB");
+	});
+});
+
+describe("formatDelta", () => {
+	const base = { kilo: 1024, threshold: 0 };
+
+	it("shows growth with an up arrow, kB and percent", () => {
+		expect(formatDelta({ ...base, size: 266076, previous: 264806 })).toBe(
+			"▲ +1.24 kB (+0.48%)",
+		);
+	});
+
+	it("shows shrinkage with a down arrow and minus signs", () => {
+		expect(formatDelta({ ...base, size: 49152, previous: 50176 })).toBe(
+			"▼ −1 kB (−2.04%)",
+		);
+	});
+
+	it("shows no change for equal sizes", () => {
+		expect(formatDelta({ ...base, size: 1000, previous: 1000 })).toBe(
+			"= no change",
+		);
+	});
+
+	it("treats changes under the threshold as no change", () => {
+		expect(
+			formatDelta({ kilo: 1024, threshold: 15, size: 1014, previous: 1000 }),
+		).toBe("= no change");
+		expect(
+			formatDelta({ kilo: 1024, threshold: 15, size: 1015, previous: 1000 }),
+		).toBe("▲ +15 B (+1.50%)");
+	});
+
+	it("labels an entry missing from the baseline as new", () => {
+		expect(formatDelta({ ...base, size: 1000, previous: undefined })).toBe(
+			"new",
+		);
+	});
+
+	it("omits the percentage when the baseline was empty", () => {
+		expect(formatDelta({ ...base, size: 2048, previous: 0 })).toBe("▲ +2 kB");
+	});
+
+	it("never points the arrow against the direction of change", () => {
+		const threshold = 15;
+		for (const diff of [-1000, -16, -15, -14, -1, 0, 1, 14, 15, 16, 1000]) {
+			const delta = formatDelta({
+				kilo: 1000,
+				threshold,
+				size: 5000 + diff,
+				previous: 5000,
+			});
+			if (Math.abs(diff) < threshold) {
+				expect(delta).toBe("= no change");
+			} else if (diff > 0) {
+				expect(delta.startsWith("▲ +")).toBe(true);
+			} else {
+				expect(delta.startsWith("▼ −")).toBe(true);
+			}
+		}
+	});
+});
+
+describe("compareSizes", () => {
+	const current = [
+		{ name: "first-paint", size: 150425, sizeLimit: 153000, passed: true },
+	];
+
+	it("renders the table with a vs main column and the baseline commit", () => {
+		const { data, passed } = compareSizes({
+			current,
+			baseline: [{ name: "first-paint", size: 151142 }],
+			baseSha: "a41c9e2d0b5f",
+			kilo: 1000,
+		});
+		expect(passed).toBe(true);
+		expect(data).toBe(
+			[
+				"## Bundle Size",
+				"",
+				"| Status | Section | Size (gzip) | vs main | Limit (gzip) |",
+				"| --- | --- | --- | --- | --- |",
+				"| ✅ | first-paint | 150.43 kB | ▼ −717 B (−0.47%) | 153 kB |",
+				"",
+				"<sub>Compared with `main` @ `a41c9e2`.</sub>",
+				"",
+			].join("\n"),
+		);
+	});
+
+	it("says so when there is no baseline", () => {
+		const { data } = compareSizes({ current, baseSha: "a41c9e2" });
+		expect(data).toContain("| ✅ | first-paint | 146.9 kB | n/a | 149.41 kB |");
+		expect(data).toContain(
+			"<sub>⚠️ No baseline found for `main` @ `a41c9e2`, so no change is shown.</sub>",
+		);
+	});
+
+	it("omits the commit when none is given", () => {
+		const { data } = compareSizes({ current, baseline: [] });
+		expect(data).toContain("<sub>Compared with `main`.</sub>");
+		expect(data).toContain("| new |");
+	});
+
+	it("uses the custom header, base ref and footer", () => {
+		const { data } = compareSizes({
+			current,
+			baseline: current,
+			header: "### First-paint bundle",
+			baseRef: "develop",
+			footer: "<sub>Budget lives in .size-limit.json.</sub>",
+		});
+		expect(data.startsWith("### First-paint bundle\n")).toBe(true);
+		expect(data).toContain("| vs develop |");
+		expect(data).toContain("Compared with `develop`.");
+		expect(
+			data.endsWith("<sub>Budget lives in .size-limit.json.</sub>\n"),
+		).toBe(true);
+	});
+
+	it("fails an entry over its limit even when it says it passed", () => {
+		const result = compareSizes({
+			current: [{ name: "a", size: 11, sizeLimit: 10, passed: true }],
+		});
+		expect(result.passed).toBe(false);
+		expect(result.data).toContain("| ❌ | a |");
+	});
+
+	it("lists baseline entries that are gone from this run", () => {
+		const { data } = compareSizes({
+			current: [{ name: "a", size: 1 }],
+			baseline: [
+				{ name: "a", size: 1 },
+				{ name: "gone", size: 12288 },
+			],
+		});
+		expect(data).toContain("| ➖ | gone | — | removed (−12 kB) | — |");
+	});
+
+	it("says why the baseline is missing when a reason is given", () => {
+		const { data } = compareSizes({
+			current: [{ name: "a", size: 1 }],
+			baseSha: "abc1234",
+			missingReason: "the baseline file could not be read",
+		});
+		expect(data).toContain(
+			"<sub>⚠️ No baseline found for `main` @ `abc1234` (the baseline file could not be read), so no change is shown.</sub>",
+		);
+	});
+
+	it("fails when an entry is over its limit, with or without passed", () => {
+		expect(
+			compareSizes({ current: [{ name: "a", size: 11, sizeLimit: 10 }] })
+				.passed,
+		).toBe(false);
+		expect(
+			compareSizes({ current: [{ name: "a", size: 1, passed: false }] }).passed,
+		).toBe(false);
+		expect(compareSizes({ current: [{ name: "a", size: 1 }] }).passed).toBe(
+			true,
+		);
+	});
+
+	it("marks failing rows and shows a dash for a missing limit", () => {
+		const { data } = compareSizes({
+			current: [
+				{ name: "over", size: 11, sizeLimit: 10 },
+				{ name: "free", size: 5 },
+			],
+		});
+		expect(data).toContain("| ❌ | over | 11 B | n/a | 10 B |");
+		expect(data).toContain("| ✅ | free | 5 B | n/a | — |");
+	});
+
+	it("escapes the base ref in the header and keeps the note on one line", () => {
+		const { data } = compareSizes({
+			current: [{ name: "x>y", size: 1 }],
+			baseline: [],
+			baseRef: "a|b\n\n## Forged",
+		});
+		expect(data).toContain("| vs a\\|b ## Forged | Limit (gzip) |");
+		expect(data).toContain("Compared with `a|b ## Forged`.");
+		expect(data).toContain("| x&gt;y |");
+		expect(data.split("\n").some((line) => line.startsWith("## Forged"))).toBe(
+			false,
+		);
+	});
+
+	it("keeps backticks in the base ref from breaking the code span", () => {
+		const { data } = compareSizes({
+			current: [{ name: "a", size: 1 }],
+			baseline: [],
+			baseRef: "ma`in",
+			baseSha: "ab`c1234",
+		});
+		expect(data).toContain("Compared with `main` @ `abc123`.");
+	});
+
+	it("escapes pipes in names so the table keeps its columns", () => {
+		const { data } = compareSizes({ current: [{ name: "a|b", size: 1 }] });
+		expect(data).toContain("| a\\|b |");
+	});
+
+	it("keeps every name inside its own table row", () => {
+		const { data } = compareSizes({
+			current: [
+				{ name: "a\n\n## Injected\n<!--", size: 999999, sizeLimit: 10 },
+				{ name: "b\\|extra", size: 1 },
+				{ name: "ping @someone", size: 1 },
+			],
+		});
+		const rows = data.split("\n").filter((line) => line.startsWith("| "));
+		// Header, separator and one line per entry: nothing escaped the table.
+		expect(rows).toHaveLength(5);
+		expect(
+			data.split("\n").some((line) => line.startsWith("## Injected")),
+		).toBe(false);
+		expect(data).not.toContain("<!--");
+		expect(data).toContain("| ❌ | a ## Injected &lt;!-- |");
+		expect(data).toContain("| b\\\\\\|extra |");
+		expect(data).toContain("ping @&#8203;someone");
+	});
+});
diff --git a/packages/bundlesize/src/__tests__/compareStats.test.ts b/packages/bundlesize/src/__tests__/compareStats.test.ts
new file mode 100644
index 00000000..6893c5e5
--- /dev/null
+++ b/packages/bundlesize/src/__tests__/compareStats.test.ts
@@ -0,0 +1,255 @@
+import {
+	chmodSync,
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { compareStats } from "../compareStats.js";
+import { STDOUT } from "../utilities.js";
+
+let dir: string;
+const write = (name: string, content: unknown) => {
+	const file = join(dir, name);
+	writeFileSync(
+		file,
+		typeof content === "string" ? content : JSON.stringify(content),
+	);
+	return file;
+};
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "bundlesize-compare-"));
+});
+
+afterEach(() => {
+	rmSync(dir, { recursive: true, force: true });
+});
+
+describe("compareStats", () => {
+	it("compares size-limit JSON against a baseline file", () => {
+		const current = write("current.json", [
+			{ name: "first-paint", passed: true, size: 2048, sizeLimit: 4096 },
+		]);
+		const baseline = write("baseline.json", [
+			{ name: "first-paint", size: 1024 },
+		]);
+		const result = compareStats({
+			flags: { kilo: 1024, current, baseline, baseSha: "abc1234" },
+		});
+		expect(result.exitCode).toBe(0);
+		expect(result.exitMessage).toBe("");
+		expect(result.outputFile).toBe(STDOUT);
+		expect(result.data).toContain("| ▲ +1 kB (+100.00%) |");
+		expect(result.data).toContain("Compared with `main` @ `abc1234`.");
+	});
+
+	it("renders the no-baseline note when the baseline file is missing", () => {
+		const current = write("current.json", [{ name: "a", size: 1 }]);
+		const result = compareStats({
+			flags: { kilo: 1024, current, baseline: join(dir, "missing.json") },
+		});
+		expect(result.exitCode).toBe(0);
+		expect(result.data).toContain("No baseline found");
+	});
+
+	it("passes header, footer, base ref, kilo and threshold through", () => {
+		const current = write("current.json", [
+			{ name: "a", size: 1010, sizeLimit: 2000 },
+		]);
+		const baseline = write("baseline.json", [{ name: "a", size: 1000 }]);
+		const result = compareStats({
+			flags: {
+				current,
+				baseline,
+				header: "### Custom",
+				footer: "done",
+				baseRef: "trunk",
+				kilo: 1000,
+				threshold: 20,
+			},
+		});
+		expect(result.data).toContain("### Custom");
+		expect(result.data).toContain("| vs trunk |");
+		expect(result.data).toContain("| 1.01 kB | = no change | 2 kB |");
+		expect(result.data).toContain("done\n");
+	});
+
+	it("exits 1 when over the limit unless silent", () => {
+		const current = write("current.json", [
+			{ name: "a", size: 11, sizeLimit: 10 },
+		]);
+		expect(compareStats({ flags: { kilo: 1024, current } }).exitCode).toBe(1);
+		expect(
+			compareStats({ flags: { kilo: 1024, current, silent: true } }).exitCode,
+		).toBe(0);
+	});
+
+	it("resolves the output file", () => {
+		const current = write("current.json", [{ name: "a", size: 1 }]);
+		const result = compareStats({
+			flags: { kilo: 1024, current, output: "tmp/out.md" },
+		});
+		expect(result.outputFile).toBe(join(process.cwd(), "tmp/out.md"));
+	});
+
+	it("requires --kilo so size-limit sizes are not read as 1024-based", () => {
+		const current = write("current.json", [{ name: "a", size: 1 }]);
+		const result = compareStats({ flags: { current } });
+		expect(result.exitCode).toBe(1);
+		expect(result.exitMessage).toContain("--kilo is required");
+	});
+
+	it("rejects duplicate entry names", () => {
+		const result = compareStats({
+			flags: {
+				current: write("dupes.json", [
+					{ name: "a", size: 1 },
+					{ name: "a", size: 2 },
+				]),
+				kilo: 1000,
+			},
+		});
+		expect(result.exitCode).toBe(1);
+		expect(result.exitMessage).toContain('Duplicate entry name "a"');
+	});
+
+	it("falls back to no baseline, with a warning, when the baseline is bad", () => {
+		const current = write("current.json", [{ name: "a", size: 1 }]);
+		for (const content of [
+			"{oops",
+			{ error: "Build not found" },
+			[{ name: 1 }],
+		]) {
+			const baseline = write("baseline.json", content);
+			const result = compareStats({
+				flags: { current, baseline, kilo: 1000, silent: true },
+			});
+			expect(result.exitCode).toBe(0);
+			expect(result.exitMessage).toBe("");
+			expect(result.warning).toContain(baseline);
+			expect(result.data).toContain(
+				"No baseline found for `main` (the baseline file could not be read)",
+			);
+		}
+	});
+
+	it("requires --current", () => {
+		const result = compareStats({ flags: {} });
+		expect(result.exitCode).toBe(1);
+		expect(result.exitMessage).toContain("--current");
+	});
+
+	it("rejects a kilo other than 1000 or 1024", () => {
+		const current = write("current.json", [{ name: "a", size: 1 }]);
+		const result = compareStats({ flags: { current, kilo: 1001 } });
+		expect(result.exitCode).toBe(1);
+		expect(result.exitMessage).toBe("--kilo must be 1000 or 1024");
+	});
+
+	it("rejects a threshold that is not a byte count", () => {
+		const current = write("current.json", [{ name: "a", size: 1 }]);
+		for (const threshold of [Number.NaN, -1, Number.POSITIVE_INFINITY]) {
+			const result = compareStats({
+				flags: { kilo: 1024, current, threshold },
+			});
+			expect(result.exitCode).toBe(1);
+			expect(result.exitMessage).toBe(
+				"--threshold must be a number of bytes, 0 or more",
+			);
+		}
+	});
+
+	it("rejects an infinite size", () => {
+		// JSON has no Infinity literal, but 1e999 overflows to it when parsed.
+		const current = write("inf.json", '[{"name":"a","size":1e999}]');
+		expect(
+			compareStats({ flags: { kilo: 1024, current } }).exitMessage,
+		).toContain("Invalid sizes file");
+	});
+
+	it("warns when the baseline cannot even be checked for", () => {
+		const current = write("current.json", [{ name: "a", size: 1 }]);
+		const locked = join(dir, "locked");
+		mkdirSync(locked);
+		writeFileSync(join(locked, "baseline.json"), "[]");
+		chmodSync(locked, 0o000);
+		try {
+			const result = compareStats({
+				flags: { kilo: 1024, current, baseline: join(locked, "baseline.json") },
+			});
+			expect(result.exitCode).toBe(0);
+			expect(result.warning).toContain("Ignoring the baseline");
+			expect(result.data).toContain("(the baseline file could not be read)");
+		} finally {
+			chmodSync(locked, 0o700);
+		}
+	});
+
+	it("rejects negative sizes and limits", () => {
+		for (const entry of [
+			{ name: "a", size: -5 },
+			{ name: "a", size: 5, sizeLimit: -1 },
+		]) {
+			expect(
+				compareStats({
+					flags: { kilo: 1024, current: write("neg.json", [entry]) },
+				}).exitMessage,
+			).toContain("Invalid sizes file");
+		}
+	});
+
+	it("surfaces the error size-limit printed instead of sizes", () => {
+		const result = compareStats({
+			flags: {
+				kilo: 1024,
+				current: write("error.json", { error: "Build not found" }),
+			},
+		});
+		expect(result.exitCode).toBe(1);
+		expect(result.exitMessage).toContain("reports an error: Build not found");
+	});
+
+	it("reports unreadable and malformed files", () => {
+		expect(
+			compareStats({ flags: { kilo: 1024, current: join(dir, "nope.json") } })
+				.exitMessage,
+		).toContain("Failed to read JSON file");
+		expect(
+			compareStats({
+				flags: { kilo: 1024, current: write("bad.json", "{oops") },
+			}).exitMessage,
+		).toContain("Failed to read JSON file");
+		expect(
+			compareStats({
+				flags: { kilo: 1024, current: write("object.json", { sizes: [] }) },
+			}).exitMessage,
+		).toContain("expected an array");
+		expect(
+			compareStats({
+				flags: {
+					kilo: 1024,
+					current: write("wrong.json", [{ name: "a", size: "1" }]),
+				},
+			}).exitMessage,
+		).toContain("Invalid sizes file");
+		expect(
+			compareStats({
+				flags: { kilo: 1024, current: write("nulls.json", [null]) },
+			}).exitMessage,
+		).toContain("Invalid sizes file");
+		expect(
+			compareStats({
+				flags: {
+					kilo: 1024,
+					current: write("types.json", [
+						{ name: "a", size: 1, sizeLimit: "10", passed: "yes" },
+					]),
+				},
+			}).exitMessage,
+		).toContain("Invalid sizes file");
+	});
+});
diff --git a/packages/bundlesize/src/bundlesize.ts b/packages/bundlesize/src/bundlesize.ts
index cffd1872..2bbeda7f 100644
--- a/packages/bundlesize/src/bundlesize.ts
+++ b/packages/bundlesize/src/bundlesize.ts
@@ -4,6 +4,7 @@
 
 import { Logger } from "@node-cli/logger";
 import fs from "fs-extra";
+import { compareStats } from "./compareStats.js";
 import { getRawStats } from "./getRawStats.js";
 import { config } from "./parse.js";
 import { reportStats } from "./reportStats.js";
@@ -15,6 +16,15 @@ const log = new Logger({
 	boring: flags.boring,
 });
 
+const writeTextOutput = (outputFile: string, data: string) => {
+	try {
+		fs.outputFileSync(outputFile, data);
+	} catch (error) {
+		log.error(`Failed to write to file: ${error.message}`);
+		process.exit(1);
+	}
+};
+
 if (flags.type === "size") {
 	try {
 		const result = await getRawStats({ flags });
@@ -62,12 +72,7 @@ if (flags.type === "report") {
 			log.info(`Output: ${result.outputFile}`);
 			log.log(result.data);
 		} else {
-			try {
-				fs.outputFileSync(result.outputFile, result.data);
-			} catch (error) {
-				log.error(`Failed to write to file: ${error.message}`);
-				process.exit(1);
-			}
+			writeTextOutput(result.outputFile, result.data);
 		}
 		process.exit(result.exitCode);
 	} catch (error) {
@@ -76,5 +81,24 @@ if (flags.type === "report") {
 	}
 }
 
-log.error("Invalid type, please use 'size' or 'report'");
+if (flags.type === "compare") {
+	const result = compareStats({ flags });
+
+	if (result.exitMessage !== "") {
+		log.error(result.exitMessage);
+		process.exit(result.exitCode);
+	}
+	if (result.warning !== "") {
+		log.warn(result.warning);
+	}
+
+	if (result.outputFile === STDOUT) {
+		log.log(result.data);
+	} else {
+		writeTextOutput(result.outputFile, result.data);
+	}
+	process.exit(result.exitCode);
+}
+
+log.error("Invalid type, please use 'size', 'report' or 'compare'");
 process.exit(1);
diff --git a/packages/bundlesize/src/compare.ts b/packages/bundlesize/src/compare.ts
new file mode 100644
index 00000000..7fba2b3d
--- /dev/null
+++ b/packages/bundlesize/src/compare.ts
@@ -0,0 +1,202 @@
+import { DEFAULT_HEADER, DEFAULT_THRESHOLD } from "./defaults.js";
+
+/**
+ * One measured entry, in the shape `size-limit --json` prints. Any tool can
+ * produce it: `size` and `sizeLimit` are in bytes, and `passed` falls back to
+ * `size <= sizeLimit` when absent.
+ */
+export interface SizeResult {
+	name: string;
+	size: number;
+	sizeLimit?: number;
+	passed?: boolean;
+}
+
+export interface CompareOptions {
+	/**
+	 * Sizes measured by this run.
+	 */
+	current: SizeResult[];
+	/**
+	 * Sizes measured on the base branch, or null when none could be found.
+	 */
+	baseline?: SizeResult[] | null;
+	/**
+	 * Markdown heading printed above the table.
+	 * @default "## Bundle Size"
+	 */
+	header?: string;
+	/**
+	 * Name of the branch the baseline was measured on.
+	 * @default "main"
+	 */
+	baseRef?: string;
+	/**
+	 * Commit the baseline was measured on, shown next to baseRef.
+	 */
+	baseSha?: string;
+	/**
+	 * Markdown appended after the table.
+	 */
+	footer?: string;
+	/**
+	 * Bytes per kB: 1000 matches size-limit's units, 1024 matches rsbuild's.
+	 * @default 1024
+	 */
+	kilo?: 1000 | 1024;
+	/**
+	 * Changes smaller than this many bytes are reported as no change.
+	 * @default 0
+	 */
+	threshold?: number;
+	/**
+	 * Why there is no baseline, appended to the "no baseline" note.
+	 */
+	missingReason?: string;
+}
+
+export interface CompareResult {
+	data: string;
+	passed: boolean;
+}
+
+const UNITS = ["B", "kB", "MB"];
+
+const round = (value: number): number => Number.parseFloat(value.toFixed(2));
+
+export const formatSize = (size: number, kilo: number): string => {
+	if (size < 1) {
+		return `${round(size)} B`;
+	}
+	let exponent = Math.min(
+		Math.floor(Math.log(size) / Math.log(kilo)),
+		UNITS.length - 1,
+	);
+	// Rounding can land on a whole next unit, e.g. 1048575 B is "1024 kB".
+	if (round(size / kilo ** exponent) >= kilo && exponent < UNITS.length - 1) {
+		exponent += 1;
+	}
+	return `${round(size / kilo ** exponent)} ${UNITS[exponent]}`;
+};
+
+export const formatDelta = ({
+	size,
+	previous,
+	kilo,
+	threshold,
+}: {
+	size: number;
+	previous: number | undefined;
+	kilo: number;
+	threshold: number;
+}): string => {
+	if (previous === undefined) {
+		return "new";
+	}
+	const diff = size - previous;
+	if (Math.abs(diff) < threshold || diff === 0) {
+		return "= no change";
+	}
+	const arrow = diff > 0 ? "▲" : "▼";
+	const sign = diff > 0 ? "+" : "−";
+	const amount = formatSize(Math.abs(diff), kilo);
+	if (previous === 0) {
+		return `${arrow} ${sign}${amount}`;
+	}
+	const percent = ((Math.abs(diff) / previous) * 100).toFixed(2);
+	return `${arrow} ${sign}${amount} (${sign}${percent}%)`;
+};
+
+/**
+ * Keep untrusted text inside its table cell: a newline would end the table and
+ * let the rest render as markdown, `<` opens HTML or a comment, and `@` pings,
+ * which a zero-width space after it prevents.
+ */
+const escapeCell = (text: string): string =>
+	text
+		.replace(/\p{Cc}+/gu, " ")
+		.replaceAll("\\", "\\\\")
+		.replaceAll("|", "\\|")
+		.replaceAll("<", "&lt;")
+		.replaceAll(">", "&gt;")
+		.replaceAll("@", "@&#8203;");
+
+// Keep a value on one line inside its code span.
+const toCodeSpan = (text: string): string =>
+	text.replace(/\p{Cc}+/gu, " ").replaceAll("`", "");
+
+const formatRef = (baseRef: string, baseSha?: string): string => {
+	const ref = `\`${toCodeSpan(baseRef)}\``;
+	return baseSha ? `${ref} @ \`${toCodeSpan(baseSha.slice(0, 7))}\`` : ref;
+};
+
+/**
+ * Render a markdown size report with a "vs <baseRef>" column comparing each
+ * entry of `current` with the entry of the same name in `baseline`.
+ */
+export const compareSizes = ({
+	current,
+	baseline = null,
+	header = DEFAULT_HEADER,
+	baseRef = "main",
+	baseSha,
+	footer,
+	kilo = 1024,
+	threshold = DEFAULT_THRESHOLD,
+	missingReason,
+}: CompareOptions): CompareResult => {
+	const previousSizes = new Map(
+		(baseline ?? []).map((entry) => [entry.name, entry.size]),
+	);
+	let passed = true;
+
+	const rows = current.map((entry) => {
+		const entryPassed =
+			entry.passed !== false &&
+			(entry.sizeLimit === undefined || entry.size <= entry.sizeLimit);
+		if (!entryPassed) {
+			passed = false;
+		}
+		const delta = baseline
+			? formatDelta({
+					size: entry.size,
+					previous: previousSizes.get(entry.name),
+					kilo,
+					threshold,
+				})
+			: "n/a";
+		const limit =
+			entry.sizeLimit === undefined ? "—" : formatSize(entry.sizeLimit, kilo);
+		return `| ${entryPassed ? "✅" : "❌"} | ${escapeCell(entry.name)} | ${formatSize(entry.size, kilo)} | ${delta} | ${limit} |`;
+	});
+
+	const currentNames = new Set(current.map((entry) => entry.name));
+	const removed = (baseline ?? [])
+		.filter((entry) => !currentNames.has(entry.name))
+		.map(
+			(entry) =>
+				`| ➖ | ${escapeCell(entry.name)} | — | removed (−${formatSize(entry.size, kilo)}) | — |`,
+		);
+
+	const reference = formatRef(baseRef, baseSha);
+	const reason = missingReason ? ` (${missingReason})` : "";
+	const note = baseline
+		? `<sub>Compared with ${reference}.</sub>`
+		: `<sub>⚠️ No baseline found for ${reference}${reason}, so no change is shown.</sub>`;
+
+	const lines = [
+		header,
+		"",
+		`| Status | Section | Size (gzip) | vs ${escapeCell(baseRef)} | Limit (gzip) |`,
+		"| --- | --- | --- | --- | --- |",
+		...rows,
+		...removed,
+		"",
+		note,
+	];
+	if (footer) {
+		lines.push("", footer);
+	}
+
+	return { data: `${lines.join("\n")}\n`, passed };
+};
diff --git a/packages/bundlesize/src/compareStats.ts b/packages/bundlesize/src/compareStats.ts
new file mode 100644
index 00000000..2cd0d3e5
--- /dev/null
+++ b/packages/bundlesize/src/compareStats.ts
@@ -0,0 +1,176 @@
+import fs from "fs-extra";
+import { compareSizes, type SizeResult } from "./compare.js";
+import type { Flags } from "./parse.js";
+import { getOutputFile, readJSONFile } from "./utilities.js";
+
+type CompareFlags = Pick<
+	Flags,
+	| "current"
+	| "baseline"
+	| "header"
+	| "baseRef"
+	| "baseSha"
+	| "footer"
+	| "kilo"
+	| "threshold"
+	| "output"
+	| "silent"
+>;
+
+type CompareStatsResult = {
+	data: string;
+	exitCode: number;
+	exitMessage: string;
+	outputFile: string;
+	/**
+	 * Something worth printing that did not stop the report.
+	 */
+	warning: string;
+};
+
+const isByteCount = (value: unknown): boolean =>
+	typeof value === "number" && Number.isFinite(value) && value >= 0;
+
+const isSizeResult = (value: unknown): value is SizeResult => {
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+	const entry = value as Record<string, unknown>;
+	return (
+		typeof entry.name === "string" &&
+		isByteCount(entry.size) &&
+		(entry.sizeLimit === undefined || isByteCount(entry.sizeLimit)) &&
+		(entry.passed === undefined || typeof entry.passed === "boolean")
+	);
+};
+
+/**
+ * False only when the file is certainly absent: a stat that fails for another
+ * reason, such as a denied parent directory, must still surface as a warning.
+ */
+const baselineMayExist = (file: string): boolean => {
+	try {
+		return fs.statSync(file, { throwIfNoEntry: false }) !== undefined;
+	} catch {
+		return true;
+	}
+};
+
+/**
+ * Read a sizes file. Returns an error message instead of throwing so the CLI
+ * can report which file was bad.
+ */
+export const readSizes = (
+	file: string,
+): { sizes: SizeResult[]; error: string } => {
+	const json = readJSONFile(file);
+	if (json.exitMessage !== "") {
+		return { sizes: [], error: json.exitMessage };
+	}
+	const data: unknown = json.data;
+	if (
+		typeof data === "object" &&
+		data !== null &&
+		typeof (data as { error?: unknown }).error === "string"
+	) {
+		// What `size-limit --json` prints when its own run fails.
+		return {
+			sizes: [],
+			error: `Sizes file ${file} reports an error: ${(data as { error: string }).error}`,
+		};
+	}
+	if (!Array.isArray(data) || !data.every(isSizeResult)) {
+		return {
+			sizes: [],
+			error: `Invalid sizes file ${file}: expected an array of { name, size, sizeLimit?, passed? } with non-negative sizes`,
+		};
+	}
+	const names = new Set<string>();
+	for (const entry of data) {
+		if (names.has(entry.name)) {
+			return {
+				sizes: [],
+				error: `Duplicate entry name "${entry.name}" in sizes file ${file}: give each size-limit check its own \`name\``,
+			};
+		}
+		names.add(entry.name);
+	}
+	return { sizes: data, error: "" };
+};
+
+/**
+ * CLI entry for `--type compare`. Only a bad --current fails the run: a missing
+ * baseline renders the "no baseline" note, and an unreadable one does too, plus
+ * a warning, so a broken artifact on main cannot block every PR.
+ */
+export const compareStats = ({
+	flags,
+}: {
+	flags: CompareFlags;
+}): CompareStatsResult => {
+	const result: CompareStatsResult = {
+		data: "",
+		exitCode: 0,
+		exitMessage: "",
+		outputFile: getOutputFile(flags.output),
+		warning: "",
+	};
+	const fail = (exitMessage: string): CompareStatsResult => ({
+		...result,
+		exitCode: 1,
+		exitMessage,
+	});
+
+	if (!flags.current) {
+		return fail("Please provide the current sizes file with --current");
+	}
+	if (flags.kilo === undefined) {
+		return fail(
+			"--kilo is required: 1000 for size-limit sizes, 1024 for rsbuild sizes",
+		);
+	}
+	if (flags.kilo !== 1000 && flags.kilo !== 1024) {
+		return fail("--kilo must be 1000 or 1024");
+	}
+	if (
+		flags.threshold !== undefined &&
+		!(Number.isFinite(flags.threshold) && flags.threshold >= 0)
+	) {
+		return fail("--threshold must be a number of bytes, 0 or more");
+	}
+
+	const current = readSizes(flags.current);
+	if (current.error) {
+		return fail(current.error);
+	}
+
+	let baseline: SizeResult[] | null = null;
+	let missingReason: string | undefined;
+	if (flags.baseline && baselineMayExist(flags.baseline)) {
+		const previous = readSizes(flags.baseline);
+		if (previous.error) {
+			result.warning = `Ignoring the baseline: ${previous.error}`;
+			missingReason = "the baseline file could not be read";
+		} else {
+			baseline = previous.sizes;
+		}
+	}
+
+	const { data, passed } = compareSizes({
+		current: current.sizes,
+		baseline,
+		header: flags.header || undefined,
+		baseRef: flags.baseRef || undefined,
+		baseSha: flags.baseSha || undefined,
+		footer: flags.footer || undefined,
+		kilo: flags.kilo as 1000 | 1024,
+		threshold: flags.threshold,
+		missingReason,
+	});
+
+	return {
+		...result,
+		data,
+		exitCode: passed || flags.silent ? 0 : 1,
+	};
+};
diff --git a/packages/bundlesize/src/config.ts b/packages/bundlesize/src/config.ts
index 25ef5e86..a21dbb54 100644
--- a/packages/bundlesize/src/config.ts
+++ b/packages/bundlesize/src/config.ts
@@ -1,5 +1,12 @@
 import type { FooterProperties } from "./utilities.js";
 
+export {
+	type CompareOptions,
+	type CompareResult,
+	compareSizes,
+	type SizeResult,
+} from "./compare.js";
+
 /**
  * Configuration for a single file size entry.
  */
diff --git a/packages/bundlesize/src/defaults.ts b/packages/bundlesize/src/defaults.ts
index c081c935..a699d5a2 100644
--- a/packages/bundlesize/src/defaults.ts
+++ b/packages/bundlesize/src/defaults.ts
@@ -9,3 +9,5 @@ export const defaultFlags = {
 };
 
 export const DEFAULT_THRESHOLD = 0;
+
+export const DEFAULT_HEADER = "## Bundle Size";
diff --git a/packages/bundlesize/src/parse.ts b/packages/bundlesize/src/parse.ts
index 519c619c..080c989b 100644
--- a/packages/bundlesize/src/parse.ts
+++ b/packages/bundlesize/src/parse.ts
@@ -10,8 +10,16 @@ export type Flags = {
 	output?: string;
 	prefix?: string;
 	silent?: boolean;
-	type?: "size" | "report";
+	type?: "size" | "report" | "compare";
 	force?: boolean;
+	current?: string;
+	baseline?: string;
+	header?: string;
+	baseRef?: string;
+	baseSha?: string;
+	footer?: string;
+	kilo?: number;
+	threshold?: number;
 };
 
 export type Configuration = {
@@ -32,7 +40,7 @@ export const config: Configuration = parser({
 		},
 		type: {
 			shortFlag: "t",
-			description: "Specify the type of output: size or report",
+			description: "Specify the type of output: size, report or compare",
 			type: "string",
 			default: defaultFlags.type,
 		},
@@ -51,6 +59,38 @@ export const config: Configuration = parser({
 			description: "Specify a prefix to use in the output file",
 			type: "string",
 		},
+		current: {
+			description: "compare: sizes JSON measured by this run",
+			type: "string",
+		},
+		baseline: {
+			description: "compare: sizes JSON measured on the base branch",
+			type: "string",
+		},
+		header: {
+			description: "compare: markdown heading above the table",
+			type: "string",
+		},
+		baseRef: {
+			description: "compare: branch the baseline was measured on",
+			type: "string",
+		},
+		baseSha: {
+			description: "compare: commit the baseline was measured on",
+			type: "string",
+		},
+		footer: {
+			description: "compare: markdown appended after the table",
+			type: "string",
+		},
+		kilo: {
+			description: "compare: bytes per kB, 1000 or 1024",
+			type: "number",
+		},
+		threshold: {
+			description: "compare: changes under this many bytes count as none",
+			type: "number",
+		},
 		silent: {
 			shortFlag: "s",
 			default: defaultFlags.silent,
diff --git a/packages/bundlesize/src/reportStats.ts b/packages/bundlesize/src/reportStats.ts
index 7a816413..6fdcd125 100644
--- a/packages/bundlesize/src/reportStats.ts
+++ b/packages/bundlesize/src/reportStats.ts
@@ -1,6 +1,6 @@
 import { basename, dirname, join } from "node:path";
 import bytes from "bytes";
-import { DEFAULT_THRESHOLD } from "./defaults.js";
+import { DEFAULT_HEADER, DEFAULT_THRESHOLD } from "./defaults.js";
 import type { FooterProperties } from "./utilities.js";
 import {
 	addMDrow,
@@ -91,7 +91,7 @@ export const reportStats = async ({ flags }): Promise<ReportCompare> => {
 	let totalGzipSize = 0;
 
 	const threshold = configuration.report.threshold ?? DEFAULT_THRESHOLD;
-	const headerString = configuration.report.header || "## Bundle Size";
+	const headerString = configuration.report.header || DEFAULT_HEADER;
 	const footerFormatter = configuration.report.footer || formatFooter;
 	const columns = configuration.report.columns || [
 		{ status: "Status" },
diff --git a/packages/bundlesize/src/utilities.ts b/packages/bundlesize/src/utilities.ts
index 054a6e20..089565e7 100644
--- a/packages/bundlesize/src/utilities.ts
+++ b/packages/bundlesize/src/utilities.ts
@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import zlib from "node:zlib";
 import bytes from "bytes";
 import fs from "fs-extra";
@@ -18,7 +18,7 @@ export const gzipSizeFromFileSync = (file: string): number => {
 };
 
 export const getOutputFile = (file: string): string => {
-	return file === "" || file === undefined ? STDOUT : join(CWD, file);
+	return file === "" || file === undefined ? STDOUT : resolve(CWD, file);
 };
 
 export const validateConfigurationFile = (file: string): any => {