diff --git a/components.d.ts b/components.d.ts
index 923437b02..63e62a357 100644
--- a/components.d.ts
+++ b/components.d.ts
@@ -34,6 +34,8 @@ declare module 'vue' {
     ComboboxTrigger: typeof import('reka-ui')['ComboboxTrigger']
     ComboboxViewport: typeof import('reka-ui')['ComboboxViewport']
     ComboboxVirtualizer: typeof import('reka-ui')['ComboboxVirtualizer']
+    CommentCard: typeof import('./src/components/comments/CommentCard.vue')['default']
+    CommentList: typeof import('./src/components/comments/CommentList.vue')['default']
     ContextMenuContent: typeof import('reka-ui')['ContextMenuContent']
     ContextMenuItem: typeof import('reka-ui')['ContextMenuItem']
     ContextMenuPortal: typeof import('reka-ui')['ContextMenuPortal']
@@ -75,6 +77,7 @@ declare module 'vue' {
     FolderManager: typeof import('./src/components/library/FolderManager.vue')['default']
     FontConfig: typeof import('./src/components/settings/custom/FontConfig.vue')['default']
     FullPlayer: typeof import('./src/components/player/FullPlayer/index.vue')['default']
+    FullPlayerComments: typeof import('./src/components/player/FullPlayer/FullPlayerComments.vue')['default']
     HotkeyConfig: typeof import('./src/components/settings/custom/HotkeyConfig.vue')['default']
     IconLucideArrowLeftRight: typeof import('~icons/lucide/arrow-left-right')['default']
     IconLucideArrowRight: typeof import('~icons/lucide/arrow-right')['default']
@@ -164,6 +167,7 @@ declare module 'vue' {
     IconLucideSkipBack: typeof import('~icons/lucide/skip-back')['default']
     IconLucideSkipForward: typeof import('~icons/lucide/skip-forward')['default']
     IconLucideTextQuote: typeof import('~icons/lucide/text-quote')['default']
+    IconLucideThumbsUp: typeof import('~icons/lucide/thumbs-up')['default']
     IconLucideTrash: typeof import('~icons/lucide/trash')['default']
     IconLucideTrash2: typeof import('~icons/lucide/trash2')['default']
     IconLucideTriangleAlert: typeof import('~icons/lucide/triangle-alert')['default']
diff --git a/electron/main/ipc/comments.ts b/electron/main/ipc/comments.ts
index e4dbdbf0c..f548f8d10 100644
--- a/electron/main/ipc/comments.ts
+++ b/electron/main/ipc/comments.ts
@@ -1,7 +1,14 @@
 import { ipcMain } from "electron";
 import { getCommentSources, getMusicComments } from "@main/services/comments";
+import { getCreatorComments } from "@main/services/comments/creator";
+import { store } from "@main/store";
 import { coreLog } from "@main/utils/logger";
-import type { MusicCommentQuery, MusicCommentResponse } from "@shared/types/comment";
+import type {
+  MusicCommentCreatorQuery,
+  MusicCommentCreatorResponse,
+  MusicCommentQuery,
+  MusicCommentResponse,
+} from "@shared/types/comment";
 
 /** 注册评论 IPC */
 export const registerCommentsIpc = (): void => {
@@ -18,4 +25,17 @@ export const registerCommentsIpc = (): void => {
       }
     },
   );
+
+  ipcMain.handle(
+    "comments:creator",
+    async (_evt, args: MusicCommentCreatorQuery): Promise<MusicCommentCreatorResponse> => {
+      if (!store.get("comments.creatorEnabled")) return { ok: true, data: [] };
+      try {
+        return { ok: true, data: await getCreatorComments(args) };
+      } catch (err) {
+        coreLog.warn("[comments] creator failed:", err);
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    },
+  );
 };
diff --git a/electron/main/services/comments/cache.spec.ts b/electron/main/services/comments/cache.spec.ts
new file mode 100644
index 000000000..86527fbff
--- /dev/null
+++ b/electron/main/services/comments/cache.spec.ts
@@ -0,0 +1,83 @@
+// @vitest-environment node
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BoundedMap, coalesce } from "./cache";
+
+describe("评论缓存 BoundedMap", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("负缓存条目同样参与访问提升", () => {
+    const cache = new BoundedMap<string, string | null>(2);
+    cache.set("a", null);
+    cache.set("b", "b");
+    expect(cache.get("a")).toBeNull();
+    cache.set("c", "c");
+    expect(cache.get("a")).toBeNull();
+    expect(cache.get("b")).toBeUndefined();
+  });
+
+  it("过期条目读取时返回 undefined 并被删除", () => {
+    const cache = new BoundedMap<string, string>(2, 1000);
+    cache.set("a", "a");
+    vi.advanceTimersByTime(1001);
+    expect(cache.get("a")).toBeUndefined();
+  });
+
+  it("包装后能区分缺失与存了 null", () => {
+    const cache = new BoundedMap<string, string | null>(2);
+    cache.set("a", null);
+    expect(cache.get("a")).toBeNull();
+    expect(cache.get("b")).toBeUndefined();
+  });
+
+  it("超过上限时淘汰最久未使用的条目", () => {
+    const cache = new BoundedMap<string, number>(2);
+    cache.set("a", 1);
+    cache.set("b", 2);
+    cache.get("a");
+    cache.set("c", 3);
+    expect(cache.get("b")).toBeUndefined();
+    expect(cache.get("a")).toBe(1);
+    expect(cache.get("c")).toBe(3);
+  });
+});
+
+describe("在途请求合并 coalesce", () => {
+  it("同 key 并发只调用一次工厂", async () => {
+    const inflight = new Map<string, Promise<number>>();
+    const factory = vi.fn(async () => 1);
+    const [first, second] = await Promise.all([
+      coalesce(inflight, "k", factory),
+      coalesce(inflight, "k", factory),
+    ]);
+    expect(first).toBe(1);
+    expect(second).toBe(1);
+    expect(factory).toHaveBeenCalledTimes(1);
+  });
+
+  it("成功与失败后都移除在途项", async () => {
+    const inflight = new Map<string, Promise<number>>();
+    await coalesce(inflight, "ok", async () => 1);
+    expect(inflight.size).toBe(0);
+    await expect(
+      coalesce(inflight, "fail", async () => {
+        throw new Error("boom");
+      }),
+    ).rejects.toThrow("boom");
+    expect(inflight.size).toBe(0);
+  });
+
+  it("不同 key 不共享在途请求", async () => {
+    const inflight = new Map<string, Promise<string>>();
+    const factory = vi.fn(async (value: string) => value);
+    await Promise.all([
+      coalesce(inflight, "a", () => factory("a")),
+      coalesce(inflight, "b", () => factory("b")),
+    ]);
+    expect(factory).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/electron/main/services/comments/cache.ts b/electron/main/services/comments/cache.ts
new file mode 100644
index 000000000..4936cd980
--- /dev/null
+++ b/electron/main/services/comments/cache.ts
@@ -0,0 +1,81 @@
+/** 单条缓存记录，包装后 get 的 undefined 才能唯一表示「不存在」 */
+interface CacheEntry<V> {
+  value: V;
+  /** 过期时间戳（毫秒），0 表示永不过期 */
+  expireAt: number;
+}
+
+/**
+ * 有界 LRU 缓存，可选用 TTL
+ * 以条目包装存储，负缓存（null / 空数组）同样参与访问提升与淘汰
+ */
+export class BoundedMap<K, V> {
+  private readonly map = new Map<K, CacheEntry<V>>();
+
+  /**
+   * @param limit - 最大条目数，超出时淘汰最久未使用的条目
+   * @param ttlMs - 条目存活时长（毫秒），省略表示永不过期
+   */
+  constructor(
+    private readonly limit: number,
+    private readonly ttlMs?: number,
+  ) {}
+
+  /**
+   * 读取缓存值，命中时提升为最近使用，过期条目读取时清除
+   * @param key - 缓存键
+   * @returns 缓存值，不存在或已过期时返回 undefined
+   */
+  get(key: K): V | undefined {
+    const entry = this.map.get(key);
+    if (!entry) return undefined;
+    if (entry.expireAt && entry.expireAt <= Date.now()) {
+      this.map.delete(key);
+      return undefined;
+    }
+    if (this.map.size > 1) {
+      this.map.delete(key);
+      this.map.set(key, entry);
+    }
+    return entry.value;
+  }
+
+  /**
+   * 写入缓存值并淘汰超限的最旧条目
+   * @param key - 缓存键
+   * @param value - 缓存值
+   */
+  set(key: K, value: V): void {
+    this.map.delete(key);
+    this.map.set(key, {
+      value,
+      expireAt: this.ttlMs ? Date.now() + this.ttlMs : 0,
+    });
+    while (this.map.size > this.limit) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === undefined) break;
+      this.map.delete(oldest);
+    }
+  }
+}
+
+/**
+ * 合并同 key 的并发请求，Promise 落定后自动移除在途项
+ * @param inflight - 在途请求表
+ * @param key - 去重键
+ * @param factory - 实际请求工厂
+ * @returns 共享的请求 Promise
+ */
+export const coalesce = <K, T>(
+  inflight: Map<K, Promise<T>>,
+  key: K,
+  factory: () => Promise<T>,
+): Promise<T> => {
+  const pending = inflight.get(key);
+  if (pending) return pending;
+  const promise = factory().finally(() => {
+    inflight.delete(key);
+  });
+  inflight.set(key, promise);
+  return promise;
+};
diff --git a/electron/main/services/comments/creator.spec.ts b/electron/main/services/comments/creator.spec.ts
new file mode 100644
index 000000000..f2f764a6d
--- /dev/null
+++ b/electron/main/services/comments/creator.spec.ts
@@ -0,0 +1,190 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { MusicCommentItem } from "@shared/types/comment";
+import type { Track } from "@shared/types/player";
+
+const state = vi.hoisted(() => ({
+  hot: new Map<number, unknown>(),
+  fresh: new Map<number, unknown>(),
+  artists: new Map<string, unknown>(),
+  calls: [] as string[],
+  meta: { songId: "100", artistIds: ["500"] } as { songId: string; artistIds: string[] } | null,
+  metaCalls: 0,
+  creator: null as unknown as (args: {
+    sourceId: string;
+    track: Track;
+  }) => Promise<MusicCommentItem[]>,
+}));
+
+vi.mock("@main/utils/logger", () => ({ coreLog: { warn: vi.fn(), info: vi.fn() } }));
+vi.mock("./index", () => ({
+  findNeteaseSongMeta: async () => {
+    state.metaCalls += 1;
+    return state.meta;
+  },
+}));
+vi.mock("@main/apis/netease", () => ({
+  callNetease: async (name: string, params: { id?: string; offset?: number; limit?: number }) => {
+    const id = String(params.id ?? "");
+    state.calls.push(`${name}:${id}`);
+    if (name === "artists") return state.artists.get(id) ?? { status: 500, body: {} };
+    const page = Math.floor((params.offset ?? 0) / (params.limit ?? 20)) + 1;
+    const table = name === "comment_hot" ? state.hot : state.fresh;
+    const registered = table.get(page);
+    if (registered) return registered;
+    // 未注册的页视为最后一页
+    return {
+      status: 200,
+      body:
+        name === "comment_hot" ? { hotComments: [], more: false } : { comments: [], more: false },
+    };
+  },
+}));
+
+const track: Track = {
+  id: "100",
+  source: "netease",
+  title: "歌名",
+  artists: [{ id: "500", name: "歌手" }],
+  duration: 180000,
+};
+
+const creatorComment = (id: string, likedCount: number) => ({
+  commentId: id,
+  content: `内容${id}`,
+  likedCount,
+  user: { userId: 200, nickname: "主创" },
+});
+
+const listenerComment = (id: string) => ({
+  commentId: id,
+  content: `内容${id}`,
+  user: { userId: 300, nickname: "听众" },
+});
+
+/**
+ * 注册一页评论响应
+ * @param type - hot 热评 / new 普通评论
+ * @param page - 页码
+ * @param comments - 该页原始评论
+ * @param more - 该页是否还有下一页
+ */
+const setPage = (type: "hot" | "new", page: number, comments: unknown[], more: boolean): void => {
+  const body = type === "hot" ? { hotComments: comments, more } : { comments, more };
+  (type === "hot" ? state.hot : state.fresh).set(page, { status: 200, body });
+};
+
+/**
+ * 注册歌手账号解析响应
+ * @param accountId - 网易云账号 id，0 表示未绑定
+ */
+const setArtist = (accountId: number): void => {
+  state.artists.set(
+    "500",
+    accountId > 0
+      ? { status: 200, body: { artist: { accountId, name: "歌手" } } }
+      : { status: 200, body: { artist: { accountId } } },
+  );
+};
+
+const loadCreator = async (): Promise<void> => {
+  // 每次重新加载模块，避免进程级缓存跨用例串味
+  vi.resetModules();
+  state.creator = (await import("./creator")).getCreatorComments;
+};
+
+describe("主创说抓取", () => {
+  beforeEach(() => {
+    state.hot.clear();
+    state.fresh.clear();
+    state.artists.clear();
+    state.calls.length = 0;
+    state.metaCalls = 0;
+    state.meta = { songId: "100", artistIds: ["500"] };
+    setArtist(200);
+  });
+
+  it("热评首页命中时只发一次热评请求", async () => {
+    setPage("hot", 1, [creatorComment("1", 5), listenerComment("2")], true);
+    await loadCreator();
+    const result = await state.creator({ sourceId: "builtin:netease", track });
+    expect(result).toHaveLength(1);
+    expect(state.calls.filter((call) => call.startsWith("comment_hot"))).toHaveLength(1);
+    expect(state.calls.filter((call) => call.startsWith("comment_music"))).toHaveLength(0);
+  });
+
+  it("热评翻页后无命中转普通评论，首个命中页即停", async () => {
+    setPage("hot", 1, [listenerComment("1")], true);
+    setPage("hot", 2, [listenerComment("2")], true);
+    setPage("hot", 3, [listenerComment("3")], false);
+    setPage("new", 1, [creatorComment("9", 3)], true);
+    await loadCreator();
+    const result = await state.creator({ sourceId: "builtin:netease", track });
+    expect(result).toHaveLength(1);
+    expect(state.calls.filter((call) => call.startsWith("comment_hot"))).toHaveLength(3);
+    expect(state.calls.filter((call) => call.startsWith("comment_music"))).toHaveLength(1);
+  });
+
+  it("more 为假时两个阶段都立即截断", async () => {
+    setPage("hot", 1, [listenerComment("1")], false);
+    setPage("new", 1, [listenerComment("2")], false);
+    await loadCreator();
+    const result = await state.creator({ sourceId: "builtin:netease", track });
+    expect(result).toEqual([]);
+    expect(state.calls.filter((call) => call.startsWith("comment_hot"))).toHaveLength(1);
+    expect(state.calls.filter((call) => call.startsWith("comment_music"))).toHaveLength(1);
+  });
+
+  it("非 200 状态直接失败", async () => {
+    state.hot.set(1, { status: 500, body: {} });
+    await loadCreator();
+    await expect(state.creator({ sourceId: "builtin:netease", track })).rejects.toThrow(
+      "netease comment request failed: 500",
+    );
+  });
+
+  it("歌手解析失败不写负缓存，后续请求仍会重试", async () => {
+    state.artists.set("500", { status: 500, body: {} });
+    await loadCreator();
+    expect(await state.creator({ sourceId: "builtin:netease", track })).toEqual([]);
+    expect(state.calls.filter((call) => call.startsWith("artists"))).toHaveLength(1);
+    setArtist(200);
+    setPage("hot", 1, [creatorComment("1", 5)], false);
+    expect(await state.creator({ sourceId: "builtin:netease", track })).toHaveLength(1);
+    expect(state.calls.filter((call) => call.startsWith("artists"))).toHaveLength(2);
+  });
+
+  it("歌手未绑定账号时直接返回空，不请求评论", async () => {
+    setArtist(0);
+    await loadCreator();
+    expect(await state.creator({ sourceId: "builtin:netease", track })).toEqual([]);
+    expect(state.calls.filter((call) => call.startsWith("comment_hot"))).toHaveLength(0);
+  });
+
+  it("同曲第二次调用命中缓存，不再请求元信息与评论", async () => {
+    setPage("hot", 1, [creatorComment("1", 5)], true);
+    await loadCreator();
+    await state.creator({ sourceId: "builtin:netease", track });
+    const calls = state.calls.length;
+    await state.creator({ sourceId: "builtin:netease", track });
+    expect(state.calls.length).toBe(calls);
+  });
+
+  it("结果按点赞数降序", async () => {
+    setPage(
+      "hot",
+      1,
+      [creatorComment("1", 1), creatorComment("2", 30), creatorComment("3", 10)],
+      false,
+    );
+    await loadCreator();
+    const result = await state.creator({ sourceId: "builtin:netease", track });
+    expect(result.map((item) => item.id)).toEqual(["2", "3", "1"]);
+  });
+
+  it("非网易云源直接返回空且不发请求", async () => {
+    await loadCreator();
+    expect(await state.creator({ sourceId: "builtin:qqmusic", track })).toEqual([]);
+    expect(state.calls).toHaveLength(0);
+  });
+});
diff --git a/electron/main/services/comments/creator.ts b/electron/main/services/comments/creator.ts
new file mode 100644
index 000000000..9e108aa59
--- /dev/null
+++ b/electron/main/services/comments/creator.ts
@@ -0,0 +1,167 @@
+import { callNetease } from "@main/apis/netease";
+import { coreLog } from "@main/utils/logger";
+import type { MusicCommentCreatorQuery, MusicCommentItem } from "@shared/types/comment";
+import { BoundedMap, coalesce } from "./cache";
+import {
+  normalizeNeteaseCommentPage,
+  optionalString,
+  scanCreatorComments,
+  type NeteaseCommentBody,
+} from "./data";
+import { findNeteaseSongMeta } from "./index";
+
+const NETEASE_SOURCE_ID = "builtin:netease";
+const NETEASE_RESOURCE_TYPE = "R_SO_4_";
+const PAGE_LIMIT = 20;
+const MAX_HOT_PAGES = 3;
+const MAX_NEW_PAGES = 5;
+const ARTIST_ACCOUNT_CACHE_LIMIT = 200;
+const CREATOR_COMMENTS_CACHE_LIMIT = 100;
+const CREATOR_COMMENTS_TTL = 10 * 60 * 1000;
+
+/** 歌手账号解析结果，failed 表示请求异常，不能当作未绑定 */
+type ArtistAccountResult =
+  | { state: "bound"; accountId: string; artistName: string }
+  | { state: "unbound" }
+  | { state: "failed" };
+
+/** 歌手 id → 账号解析结果，只缓存确定结论 */
+const artistAccountCache = new BoundedMap<string, ArtistAccountResult>(ARTIST_ACCOUNT_CACHE_LIMIT);
+/** 网易云歌曲 id → 主创评论列表，空数组为负缓存 */
+const creatorCommentsCache = new BoundedMap<string, MusicCommentItem[]>(
+  CREATOR_COMMENTS_CACHE_LIMIT,
+  CREATOR_COMMENTS_TTL,
+);
+/** 歌手账号解析在途请求 */
+const artistAccountInflight = new Map<string, Promise<ArtistAccountResult>>();
+/** 主创评论扫描在途请求 */
+const creatorInflight = new Map<string, Promise<MusicCommentItem[]>>();
+
+/**
+ * 拉取一页网易云评论，非 200 状态抛错
+ * @param songId - 网易云歌曲 id
+ * @param type - 评论分类
+ * @param page - 页码
+ * @returns 归一化分页，含原生的 hasMore 信号
+ */
+const fetchPage = async (songId: string, type: "hot" | "new", page: number) => {
+  const apiName = type === "hot" ? "comment_hot" : "comment_music";
+  const { status, body } = await callNetease(apiName, {
+    id: songId,
+    type: NETEASE_RESOURCE_TYPE,
+    limit: PAGE_LIMIT,
+    offset: (page - 1) * PAGE_LIMIT,
+  });
+  if (status !== 200) throw new Error(`netease comment request failed: ${status}`);
+  return normalizeNeteaseCommentPage(body as NeteaseCommentBody, type, page, PAGE_LIMIT);
+};
+
+/**
+ * 解析单个歌手绑定的网易云账号
+ * 请求异常时不下结论，避免一次超时被当成永久未绑定
+ * @param artistId - 歌手 id
+ * @returns 账号解析结果
+ */
+const resolveArtistAccount = async (artistId: string): Promise<ArtistAccountResult> => {
+  const cached = artistAccountCache.get(artistId);
+  if (cached !== undefined) return cached;
+  return coalesce(artistAccountInflight, artistId, async () => {
+    try {
+      const { status, body } = await callNetease("artists", { id: artistId });
+      if (status !== 200) throw new Error(`netease artist request failed: ${status}`);
+      const rawAccountId = body?.artist?.accountId;
+      const accountId =
+        typeof rawAccountId === "number" && rawAccountId > 0
+          ? String(rawAccountId)
+          : typeof rawAccountId === "string" && rawAccountId
+            ? rawAccountId
+            : "";
+      const result: ArtistAccountResult = accountId
+        ? { state: "bound", accountId, artistName: optionalString(body?.artist?.name) ?? "" }
+        : { state: "unbound" };
+      artistAccountCache.set(artistId, result);
+      return result;
+    } catch (err) {
+      coreLog.warn(`[comments] resolve artist ${artistId} accountId failed:`, err);
+      return { state: "failed" };
+    }
+  });
+};
+
+/**
+ * 解析歌手列表对应的网易云账号
+ * @param artistIds - 歌手 id 列表
+ * @returns 账号 id → 歌手名，以及是否存在解析失败的歌手
+ */
+const resolveArtistAccountIds = async (
+  artistIds: string[],
+): Promise<{ accountMap: Map<string, string>; failed: boolean }> => {
+  const accountMap = new Map<string, string>();
+  const uniqueIds = [...new Set(artistIds.filter(Boolean))];
+  const results = await Promise.all(uniqueIds.map((artistId) => resolveArtistAccount(artistId)));
+  let failed = false;
+  for (const result of results) {
+    if (result.state === "bound") accountMap.set(result.accountId, result.artistName);
+    else if (result.state === "failed") failed = true;
+  }
+  return { accountMap, failed };
+};
+
+/**
+ * 顺序翻页扫描主创评论，命中或没有下一页时停止
+ * @param songId - 网易云歌曲 id
+ * @param type - 评论分类
+ * @param maxPages - 最多翻页数
+ * @param accountMap - 账号 id → 歌手名
+ * @returns 命中的主创评论
+ */
+const scanPages = async (
+  songId: string,
+  type: "hot" | "new",
+  maxPages: number,
+  accountMap: Map<string, string>,
+): Promise<MusicCommentItem[]> => {
+  const hits: MusicCommentItem[] = [];
+  for (let page = 1; page <= maxPages; page++) {
+    const data = await fetchPage(songId, type, page);
+    hits.push(...scanCreatorComments(data.list, accountMap));
+    if (hits.length > 0 || data.hasMore !== true) break;
+  }
+  return hits;
+};
+
+/**
+ * 获取主创说评论：歌曲关联歌手在网易云绑定的账号在该曲下的发言
+ * 先扫热评，热评无命中时才扫普通评论，两个阶段都顺序按需翻页并命中即停
+ * @param args - 评论源与曲目
+ * @returns 按点赞数降序的主创评论
+ */
+export const getCreatorComments = async (
+  args: MusicCommentCreatorQuery,
+): Promise<MusicCommentItem[]> => {
+  if (args.sourceId !== NETEASE_SOURCE_ID) return [];
+  const meta = await findNeteaseSongMeta(args.track);
+  if (!meta) return [];
+
+  const cached = creatorCommentsCache.get(meta.songId);
+  if (cached !== undefined) return cached;
+
+  return coalesce(creatorInflight, meta.songId, async () => {
+    const { accountMap, failed } = await resolveArtistAccountIds(meta.artistIds);
+    if (accountMap.size === 0) {
+      if (!failed) creatorCommentsCache.set(meta.songId, []);
+      return [];
+    }
+
+    let result = await scanPages(meta.songId, "hot", MAX_HOT_PAGES, accountMap);
+    if (result.length === 0) {
+      result = await scanPages(meta.songId, "new", MAX_NEW_PAGES, accountMap);
+    }
+
+    const seen = new Set<string>();
+    result = result.filter((item) => (seen.has(item.id) ? false : seen.add(item.id)));
+    result.sort((a, b) => (b.likedCount ?? -1) - (a.likedCount ?? -1));
+    if (!failed) creatorCommentsCache.set(meta.songId, result);
+    return result;
+  });
+};
diff --git a/electron/main/services/comments/data.spec.ts b/electron/main/services/comments/data.spec.ts
new file mode 100644
index 000000000..84578421e
--- /dev/null
+++ b/electron/main/services/comments/data.spec.ts
@@ -0,0 +1,144 @@
+// @vitest-environment node
+import { describe, expect, it } from "vitest";
+import type { MusicCommentItem } from "@shared/types/comment";
+import {
+  normalizeNeteaseComment,
+  normalizeNeteaseCommentPage,
+  normalizeQQMusicCommentPage,
+  scanCreatorComments,
+} from "./data";
+
+const comment = (overrides: Record<string, unknown> = {}) => ({
+  commentId: 1,
+  content: "内容",
+  user: { userId: 9, nickname: "听众" },
+  ...overrides,
+});
+
+describe("网易云评论归一化", () => {
+  it("top-level more 决定 hasMore", () => {
+    const page = normalizeNeteaseCommentPage(
+      { comments: [comment()], total: 100, more: true },
+      "new",
+      1,
+      20,
+    );
+    expect(page.hasMore).toBe(true);
+  });
+
+  it("回落到 data.hasMore", () => {
+    const page = normalizeNeteaseCommentPage(
+      { data: { comments: [comment()], hasMore: true } },
+      "new",
+      1,
+      20,
+    );
+    expect(page.hasMore).toBe(true);
+  });
+
+  it("两者都缺失时 hasMore 为 undefined", () => {
+    const page = normalizeNeteaseCommentPage({ comments: [comment()] }, "new", 1, 20);
+    expect(page.hasMore).toBeUndefined();
+  });
+
+  it("total 缺失时回退 0", () => {
+    const page = normalizeNeteaseCommentPage({ comments: [comment()] }, "new", 1, 20);
+    expect(page.total).toBe(0);
+  });
+
+  it("回复缺少自身 id 时用 fallbackId 生成互不相同的 id", () => {
+    const item = normalizeNeteaseComment({
+      commentId: 7,
+      content: "父评论",
+      user: { userId: 1, nickname: "甲" },
+      beReplied: [
+        { content: "回复一", user: { userId: 2, nickname: "乙" } },
+        { content: "回复二", user: { userId: 3, nickname: "丙" } },
+      ],
+    });
+    const ids = item?.reply?.map((reply) => reply.id) ?? [];
+    expect(ids).toHaveLength(2);
+    expect(new Set(ids).size).toBe(2);
+  });
+});
+
+describe("QQ 音乐评论归一化", () => {
+  it("透传 hasMore 并在为真时保留空游标", () => {
+    const page = normalizeQQMusicCommentPage(
+      { comments: [{ CmId: "1", Content: "内容", Nick: "听众" }], hasMore: true },
+      1,
+      20,
+    );
+    expect(page.hasMore).toBe(true);
+    expect(page.nextCursor).toBe("");
+  });
+
+  it("hasMore 为假时省略游标", () => {
+    const page = normalizeQQMusicCommentPage(
+      { comments: [{ CmId: "1", Content: "内容", Nick: "听众" }], hasMore: false },
+      1,
+      20,
+    );
+    expect(page.hasMore).toBe(false);
+    expect(page.nextCursor).toBeUndefined();
+  });
+});
+
+describe("主创评论扫描", () => {
+  const accountMap = new Map([["9", "主创名"]]);
+
+  it("命中顶层评论并写入 creatorName", () => {
+    const items: MusicCommentItem[] = [{ id: "1", userId: "9", userName: "a", text: "t" }];
+    const hits = scanCreatorComments(items, accountMap);
+    expect(hits).toHaveLength(1);
+    expect(hits[0]?.creatorName).toBe("主创名");
+  });
+
+  it("主创在粉丝评论下的回复同样计入", () => {
+    const items: MusicCommentItem[] = [
+      {
+        id: "1",
+        userId: "100",
+        userName: "粉丝",
+        text: "问",
+        reply: [{ id: "2", userId: "9", userName: "主创", text: "答" }],
+      },
+    ];
+    const hits = scanCreatorComments(items, accountMap);
+    expect(hits).toHaveLength(1);
+    expect(hits[0]?.id).toBe("2");
+    expect(hits[0]?.creatorName).toBe("主创名");
+  });
+
+  it("顶层主创评论下的其他主创回复也会返回", () => {
+    const items: MusicCommentItem[] = [
+      {
+        id: "1",
+        userId: "9",
+        userName: "主创甲",
+        text: "顶层",
+        reply: [{ id: "2", userId: "10", userName: "主创乙", text: "回复" }],
+      },
+    ];
+    const hits = scanCreatorComments(
+      items,
+      new Map([
+        ["9", "主创甲"],
+        ["10", "主创乙"],
+      ]),
+    );
+    expect(hits.map((hit) => hit.id)).toEqual(["1", "2"]);
+    expect(hits.map((hit) => hit.creatorName)).toEqual(["主创甲", "主创乙"]);
+  });
+
+  it("歌手名为空时 creatorName 为空串", () => {
+    const items: MusicCommentItem[] = [{ id: "1", userId: "9", userName: "a", text: "t" }];
+    const hits = scanCreatorComments(items, new Map([["9", ""]]));
+    expect(hits[0]?.creatorName).toBe("");
+  });
+
+  it("账号映射为空时返回空数组", () => {
+    const items: MusicCommentItem[] = [{ id: "1", userId: "9", userName: "a", text: "t" }];
+    expect(scanCreatorComments(items, new Map())).toEqual([]);
+  });
+});
diff --git a/electron/main/services/comments/data.ts b/electron/main/services/comments/data.ts
index 85f1d5ac7..481a8bc39 100644
--- a/electron/main/services/comments/data.ts
+++ b/electron/main/services/comments/data.ts
@@ -28,10 +28,13 @@ interface NeteaseComment {
   replyCount?: number;
 }
 
-interface NeteaseCommentBody {
+export interface NeteaseCommentBody {
   total?: number;
   hotComments?: NeteaseComment[];
   comments?: NeteaseComment[];
+  /** legacy 评论端点用顶层 more 表示还有下一页 */
+  more?: boolean;
+  hasMore?: boolean;
   data?: {
     totalCount?: number;
     comments?: NeteaseComment[];
@@ -98,21 +101,31 @@ const toStringId = (value: unknown): string => {
   return "";
 };
 
-const optionalString = (value: unknown): string | undefined => {
+export const optionalString = (value: unknown): string | undefined => {
   if (typeof value !== "string") return undefined;
   const text = value.trim();
   return text || undefined;
 };
 
-/** 转换 NCM 评论项 */
-export const normalizeNeteaseComment = (raw: NeteaseComment): MusicCommentItem | null => {
-  const id = toStringId(raw.commentId ?? raw.beRepliedCommentId);
+/**
+ * 转换 NCM 评论项
+ * @param raw - 原始评论数据
+ * @param fallbackId - 回复项缺少自身 id 时的兜底，避免多条回复共享父 id
+ * @returns 归一化评论，缺少 id 或正文时返回 null
+ */
+export const normalizeNeteaseComment = (
+  raw: NeteaseComment,
+  fallbackId?: { parentId: string; index: number },
+): MusicCommentItem | null => {
+  const id =
+    toStringId(raw.commentId ?? raw.beRepliedCommentId) ||
+    (fallbackId ? `${fallbackId.parentId}_reply_${fallbackId.index}` : "");
   const text = optionalString(raw.content);
   if (!id || !text) return null;
 
   const userId = toStringId(raw.user?.userId);
   const reply = (raw.beReplied ?? [])
-    .map((item) => normalizeNeteaseComment(item))
+    .map((item, index) => normalizeNeteaseComment(item, { parentId: id, index }))
     .filter((item): item is MusicCommentItem => item !== null);
 
   const item: MusicCommentItem = {
@@ -132,7 +145,14 @@ export const normalizeNeteaseComment = (raw: NeteaseComment): MusicCommentItem |
   return item;
 };
 
-/** 转换 NCM 评论分页 */
+/**
+ * 转换 NCM 评论分页
+ * @param body - 原始响应正文
+ * @param type - 评论分类
+ * @param page - 页码
+ * @param limit - 每页数量
+ * @returns 归一化分页，total 缺失时以 0 表示未知
+ */
 export const normalizeNeteaseCommentPage = (
   body: NeteaseCommentBody,
   type: CommentTab,
@@ -146,12 +166,15 @@ export const normalizeNeteaseCommentPage = (
   const list = rawList
     .map((item) => normalizeNeteaseComment(item))
     .filter((item): item is MusicCommentItem => item !== null);
+  // legacy 端点用顶层 more，新端点给出 data.hasMore
+  const hasMore = body.more ?? body.hasMore ?? body.data?.hasMore;
 
   return {
     list,
-    total: body.total ?? body.data?.totalCount ?? list.length,
+    total: body.total ?? body.data?.totalCount ?? 0,
     page,
     limit,
+    ...(typeof hasMore === "boolean" ? { hasMore } : {}),
   };
 };
 
@@ -184,7 +207,13 @@ export const normalizeQQMusicComment = (raw: QQMusicComment): MusicCommentItem |
   return item;
 };
 
-/** 转换 QM 评论分页 */
+/**
+ * 转换 QM 评论分页
+ * @param body - 原始响应正文
+ * @param page - 页码
+ * @param limit - 每页数量
+ * @returns 归一化分页，仍有下一页时保留游标（允许空串）
+ */
 export const normalizeQQMusicCommentPage = (
   body: QQMusicCommentBody,
   page: number,
@@ -193,12 +222,14 @@ export const normalizeQQMusicCommentPage = (
   const list = (body.comments ?? [])
     .map((item) => normalizeQQMusicComment(item))
     .filter((item): item is MusicCommentItem => item !== null);
+  const hasMore = typeof body.hasMore === "boolean" ? body.hasMore : undefined;
   return {
     list,
-    total: body.total ?? list.length,
+    total: body.total ?? 0,
     page,
     limit,
-    ...(body.hasMore && body.nextCursor ? { nextCursor: body.nextCursor } : {}),
+    ...(hasMore === undefined ? {} : { hasMore }),
+    ...(hasMore ? { nextCursor: body.nextCursor ?? "" } : {}),
   };
 };
 
@@ -245,12 +276,38 @@ export const normalizeKugouCommentPage = (
     .filter((item): item is MusicCommentItem => item !== null);
   return {
     list,
-    total: data.count ?? list.length,
+    total: data.count ?? 0,
     page: data.current_page ?? page,
     limit,
   };
 };
 
+/**
+ * 从已归一化的评论中筛出主创评论，主创在粉丝评论下的回复同样计入
+ * @param items - 已归一化的评论列表
+ * @param accountMap - 网易云账号 id → 歌手名
+ * @returns 命中的主创评论，creatorName 为对应歌手名
+ */
+export const scanCreatorComments = (
+  items: MusicCommentItem[],
+  accountMap: Map<string, string>,
+): MusicCommentItem[] => {
+  if (accountMap.size === 0) return [];
+  const result: MusicCommentItem[] = [];
+  const push = (item: MusicCommentItem, userId: string): void => {
+    result.push({ ...item, creatorName: accountMap.get(userId) ?? "" });
+  };
+  for (const item of items) {
+    const userId = item.userId;
+    if (userId && accountMap.has(userId)) push(item, userId);
+    for (const reply of item.reply ?? []) {
+      const replyUserId = reply.userId;
+      if (replyUserId && accountMap.has(replyUserId)) push(reply, replyUserId);
+    }
+  }
+  return result;
+};
+
 /** 构建可用评论源 */
 export const buildCommentSources = (
   plugins: Array<
diff --git a/electron/main/services/comments/index.ts b/electron/main/services/comments/index.ts
index 76895c136..4febaf74b 100644
--- a/electron/main/services/comments/index.ts
+++ b/electron/main/services/comments/index.ts
@@ -9,6 +9,7 @@ import { pluginLog } from "@main/utils/logger";
 import type { CommentSource, MusicCommentPage, MusicCommentQuery } from "@shared/types/comment";
 import type { MusicSearchCandidate } from "@shared/types/plugin";
 import type { Track } from "@shared/types/player";
+import { BoundedMap, coalesce } from "./cache";
 import {
   buildCommentSources,
   normalizeNeteaseCommentPage,
@@ -23,6 +24,21 @@ const QQMUSIC_SOURCE_ID = "builtin:qqmusic";
 const KUGOU_SOURCE_ID = "builtin:kugou";
 const NETEASE_RESOURCE_TYPE = "R_SO_4_";
 
+const SONG_META_CACHE_LIMIT = 200;
+
+/** 网易云歌曲元信息 */
+export type NeteaseSongMeta = { songId: string; artistIds: string[] };
+
+/** 曲目 key → 网易云歌曲元信息（null 表示负缓存），分页与主创说复用同一次搜索 */
+const songMetaCache = new BoundedMap<string, NeteaseSongMeta | null>(SONG_META_CACHE_LIMIT);
+/** 元信息解析在途请求 */
+const songMetaInflight = new Map<string, Promise<NeteaseSongMeta | null>>();
+/** QQ / 酷狗 id 解析在途请求，避免两个 tab 同时搜索同一曲目 */
+const trackIdInflight = new Map<string, Promise<string | null>>();
+
+const makeTrackKey = (track: Track): string =>
+  `${track.source}\n${track.serverId ?? ""}\n${track.id}`;
+
 const PLATFORM_TO_PLUGIN_SOURCE: Record<string, string> = {
   netease: "wy",
   qqmusic: "tx",
@@ -80,46 +96,73 @@ const findPluginMatch = async (
   return pickBestCandidate(candidates, track)?.extra ?? null;
 };
 
-const findNeteaseId = async (track: Track): Promise<string | null> => {
-  if (track.source === "netease" && track.id) return track.id;
-  const keyword = toKeyword(track);
-  if (!keyword) return null;
-  const { status, body } = await callNetease("search", {
-    keywords: keyword,
-    type: 1,
-    limit: 20,
+/**
+ * 解析曲目对应的网易云歌曲元信息
+ * 曲目本身来自网易云时直接取自身信息，其余来源走一次搜索同时取歌曲 id 与歌手 id
+ * @param track - 待解析曲目
+ * @returns 歌曲元信息，无匹配结果时返回 null
+ */
+export const findNeteaseSongMeta = async (track: Track): Promise<NeteaseSongMeta | null> => {
+  const cacheKey = makeTrackKey(track);
+  const cached = songMetaCache.get(cacheKey);
+  if (cached !== undefined) return cached;
+  if (track.source === "netease" && track.id) {
+    const meta: NeteaseSongMeta = {
+      songId: track.id,
+      artistIds: track.artists
+        .map((artist) => artist.id)
+        .filter((id): id is string => Boolean(id) && id !== "undefined"),
+    };
+    songMetaCache.set(cacheKey, meta);
+    return meta;
+  }
+  return coalesce(songMetaInflight, cacheKey, async () => {
+    const keyword = toKeyword(track);
+    if (!keyword) return null;
+    const { status, body } = await callNetease("search", {
+      keywords: keyword,
+      type: 1,
+      limit: 20,
+    });
+    if (status !== 200) return null;
+    const songs = body.result?.songs ?? [];
+    const candidates: LyricCandidate<NeteaseSongMeta>[] = songs.map(
+      (song: {
+        id: string | number;
+        name?: string;
+        artists?: { id?: string | number; name: string }[];
+        album?: { name?: string };
+        duration?: number;
+      }) => ({
+        name: song.name ?? "",
+        artist: (song.artists ?? []).map((artist) => artist.name).join(" / "),
+        album: song.album?.name,
+        duration: song.duration,
+        extra: {
+          songId: String(song.id),
+          artistIds: (song.artists ?? [])
+            .map((artist) => (artist.id ? String(artist.id) : ""))
+            .filter(Boolean),
+        },
+      }),
+    );
+    const meta = pickBestCandidate(candidates, track)?.extra ?? null;
+    songMetaCache.set(cacheKey, meta);
+    return meta;
   });
-  if (status !== 200) return null;
-  const songs = body.result?.songs ?? [];
-  const candidates: LyricCandidate<{ id: string }>[] = songs.map(
-    (song: {
-      id: string | number;
-      name?: string;
-      artists?: { name: string }[];
-      album?: { name?: string };
-      duration?: number;
-    }) => ({
-      name: song.name ?? "",
-      artist: (song.artists ?? []).map((artist) => artist.name).join(" / "),
-      album: song.album?.name,
-      duration: song.duration,
-      extra: { id: String(song.id) },
-    }),
-  );
-  return pickBestCandidate(candidates, track)?.extra.id ?? null;
 };
 
 const getNeteaseComments = async (args: MusicCommentQuery): Promise<MusicCommentPage> => {
-  const id = await findNeteaseId(args.track);
-  if (!id) return { list: [], total: 0, page: args.page, limit: args.limit };
-
+  const meta = await findNeteaseSongMeta(args.track);
+  if (!meta) return { list: [], total: 0, page: args.page, limit: args.limit, hasMore: false };
   const apiName = args.type === "hot" ? "comment_hot" : "comment_music";
-  const { body } = await callNetease(apiName, {
-    id,
+  const { status, body } = await callNetease(apiName, {
+    id: meta.songId,
     type: NETEASE_RESOURCE_TYPE,
     limit: args.limit,
     offset: (args.page - 1) * args.limit,
   });
+  if (status !== 200) throw new Error(`netease comment request failed: ${status}`);
   return normalizeNeteaseCommentPage(body, args.type, args.page, args.limit);
 };
 
@@ -129,22 +172,30 @@ const findQQMusicId = async (track: Track): Promise<string | null> => {
   }
   const keyword = toKeyword(track);
   if (!keyword) return null;
-  const body = await callQQMusic("search", { keywords: keyword, type: 0, page: 1, limit: 20 });
-  const candidates: LyricCandidate<{ id: string }>[] = (body.songs ?? []).map(
-    (song: { id?: string; name?: string; artist?: string; album?: string; duration?: number }) => ({
-      name: song.name ?? "",
-      artist: song.artist ?? "",
-      album: song.album,
-      duration: song.duration,
-      extra: { id: song.id ?? "" },
-    }),
-  );
-  return pickBestCandidate(candidates, track)?.extra.id || null;
+  return coalesce(trackIdInflight, `qqmusic\n${makeTrackKey(track)}`, async () => {
+    const body = await callQQMusic("search", { keywords: keyword, type: 0, page: 1, limit: 20 });
+    const candidates: LyricCandidate<{ id: string }>[] = (body.songs ?? []).map(
+      (song: {
+        id?: string;
+        name?: string;
+        artist?: string;
+        album?: string;
+        duration?: number;
+      }) => ({
+        name: song.name ?? "",
+        artist: song.artist ?? "",
+        album: song.album,
+        duration: song.duration,
+        extra: { id: song.id ?? "" },
+      }),
+    );
+    return pickBestCandidate(candidates, track)?.extra.id || null;
+  });
 };
 
 const getQQMusicComments = async (args: MusicCommentQuery): Promise<MusicCommentPage> => {
   const id = await findQQMusicId(args.track);
-  if (!id) return { list: [], total: 0, page: args.page, limit: args.limit };
+  if (!id) return { list: [], total: 0, page: args.page, limit: args.limit, hasMore: false };
   const body = await callQQMusic("comment", {
     id,
     type: args.type,
@@ -159,26 +210,29 @@ const findKugouId = async (track: Track): Promise<string | null> => {
   if (track.source === "kugou" && track.extId) return track.extId;
   const keyword = toKeyword(track);
   if (!keyword) return null;
-  const body = await callKugou<{ songs?: KGSong[] }>("search", {
-    keywords: keyword,
-    type: 0,
-    page: 1,
-    limit: 20,
+  return coalesce(trackIdInflight, `kugou\n${makeTrackKey(track)}`, async () => {
+    const body = await callKugou<{ songs?: KGSong[] }>("search", {
+      keywords: keyword,
+      type: 0,
+      page: 1,
+      limit: 20,
+    });
+    const candidates: LyricCandidate<{ id: string }>[] = (body.songs ?? []).map((song) => ({
+      name: song.name,
+      artist: song.artist,
+      album: song.album,
+      duration: song.duration,
+      extra: { id: song.albumAudioId ? String(song.albumAudioId) : "" },
+    }));
+    return pickBestCandidate(candidates, track)?.extra.id || null;
   });
-  const candidates: LyricCandidate<{ id: string }>[] = (body.songs ?? []).map((song) => ({
-    name: song.name,
-    artist: song.artist,
-    album: song.album,
-    duration: song.duration,
-    extra: { id: song.albumAudioId ? String(song.albumAudioId) : "" },
-  }));
-  return pickBestCandidate(candidates, track)?.extra.id || null;
 };
 
 const getKugouComments = async (args: MusicCommentQuery): Promise<MusicCommentPage> => {
-  if (args.type !== "hot") return { list: [], total: 0, page: args.page, limit: args.limit };
+  if (args.type !== "hot")
+    return { list: [], total: 0, page: args.page, limit: args.limit, hasMore: false };
   const id = await findKugouId(args.track);
-  if (!id) return { list: [], total: 0, page: args.page, limit: args.limit };
+  if (!id) return { list: [], total: 0, page: args.page, limit: args.limit, hasMore: false };
   const body = await callKugou<KugouCommentBody>("comment", {
     id,
     page: args.page,
@@ -195,7 +249,8 @@ const getPluginComments = async (
   if (!rt || rt.status.state !== "ready") throw new Error("plugin comment source is not ready");
   try {
     const musicInfo = await findPluginMatch(rt, parsed.source, args.track);
-    if (!musicInfo) return { list: [], total: 0, page: args.page, limit: args.limit };
+    if (!musicInfo)
+      return { list: [], total: 0, page: args.page, limit: args.limit, hasMore: false };
     return await callMusicComment(rt, {
       source: parsed.source,
       musicInfo,
diff --git a/electron/preload/index.ts b/electron/preload/index.ts
index c4acf4dbb..fc207f881 100644
--- a/electron/preload/index.ts
+++ b/electron/preload/index.ts
@@ -24,7 +24,7 @@ import type { PlayEventInput, FavoriteEventInput } from "@shared/types/stats";
 import type { TagEditRequest } from "@shared/types/tagEditor";
 import type { UpdateEvent } from "@shared/types/update";
 import type { CloudUploadProgress } from "@shared/types/cloudUpload";
-import type { MusicCommentQuery } from "@shared/types/comment";
+import type { MusicCommentCreatorQuery, MusicCommentQuery } from "@shared/types/comment";
 import type { AiModelSaveInput } from "@shared/types/ai";
 import type { DesktopLyricUnlockButtonBounds } from "@shared/types/window";
 import type {
@@ -532,6 +532,7 @@ const api = {
   comments: {
     sources: () => ipcRenderer.invoke("comments:sources"),
     get: (args: MusicCommentQuery) => ipcRenderer.invoke("comments:get", args),
+    creator: (args: MusicCommentCreatorQuery) => ipcRenderer.invoke("comments:creator", args),
   },
   download: {
     // 入队下载
diff --git a/shared/defaults/settings.ts b/shared/defaults/settings.ts
index adf5cb641..45869c495 100644
--- a/shared/defaults/settings.ts
+++ b/shared/defaults/settings.ts
@@ -136,6 +136,10 @@ export const defaultSystemConfig: SystemConfig = {
     nowPlaying: true,
     loveSync: true,
   },
+  comments: {
+    creatorEnabled: false,
+    density: "standard",
+  },
   externalApi: {
     enabled: false,
     wsEnabled: false,
diff --git a/shared/types/comment.ts b/shared/types/comment.ts
index 671f3fbcd..2b82a02b1 100644
--- a/shared/types/comment.ts
+++ b/shared/types/comment.ts
@@ -33,6 +33,8 @@ export interface MusicCommentItem {
   replyTotal?: number;
   reply?: MusicCommentItem[];
   hasMoreReply?: boolean;
+  /** 主创评论对应的歌手名，仅主创说结果携带 */
+  creatorName?: string;
 }
 
 /** 歌曲评论分页 */
@@ -43,6 +45,8 @@ export interface MusicCommentPage {
   limit: number;
   /** 下一页游标 */
   nextCursor?: string;
+  /** 是否还有下一页，由各来源的原生信号给出 */
+  hasMore?: boolean;
 }
 
 /** 评论查询参数 */
@@ -60,8 +64,19 @@ export interface MusicCommentQuery {
 export type MusicCommentResponse =
   { ok: true; data: MusicCommentPage } | { ok: false; error: string };
 
+/** 主创说查询参数 */
+export interface MusicCommentCreatorQuery {
+  sourceId: string;
+  track: Track;
+}
+
+/** 主创说 IPC 响应 */
+export type MusicCommentCreatorResponse =
+  { ok: true; data: MusicCommentItem[] } | { ok: false; error: string };
+
 /** 渲染端评论 API */
 export interface CommentsApi {
   sources: () => Promise<CommentSource[]>;
   get: (args: MusicCommentQuery) => Promise<MusicCommentResponse>;
+  creator: (args: MusicCommentCreatorQuery) => Promise<MusicCommentCreatorResponse>;
 }
diff --git a/shared/types/settings.ts b/shared/types/settings.ts
index 190f1418f..0b231cb2b 100644
--- a/shared/types/settings.ts
+++ b/shared/types/settings.ts
@@ -232,6 +232,17 @@ export interface StreamingSettings {
   enabled: boolean;
 }
 
+/** 评论卡片密度 */
+export type CommentDensity = "compact" | "standard" | "comfortable";
+
+/** 评论设置 */
+export interface CommentSettings {
+  /** 在评论区展示主创说 */
+  creatorEnabled: boolean;
+  /** 播放器内评论卡片密度 */
+  density: CommentDensity;
+}
+
 /** 外部 API 服务配置 */
 export interface ExternalApiSettings {
   /** 总开关 */
@@ -465,6 +476,8 @@ export interface SystemConfig {
   streaming: StreamingSettings;
   /** Last.fm 集成配置 */
   lastfm: LastfmSettings;
+  /** 评论设置 */
+  comments: CommentSettings;
   /** 外部 API 服务（HTTP + WS） */
   externalApi: ExternalApiSettings;
   /** AI 集成使用的 MCP 服务 */
diff --git a/src/components/comments/CommentCard.vue b/src/components/comments/CommentCard.vue
new file mode 100644
index 000000000..a5a327d0b
--- /dev/null
+++ b/src/components/comments/CommentCard.vue
@@ -0,0 +1,153 @@
+<script setup lang="ts">
+import type { MusicCommentItem } from "@shared/types/comment";
+import type { CommentDensity } from "@shared/types/settings";
+import { formatDate } from "@/utils/time";
+
+interface Props {
+  /** 评论数据 */
+  item: MusicCommentItem;
+  /** 是否显示主创徽章 */
+  creator?: boolean;
+  /** 评论卡片密度 */
+  density?: CommentDensity;
+  /** 是否使用全屏播放器配色 */
+  cover?: boolean;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  creator: false,
+  density: "standard",
+  cover: false,
+});
+
+/** 按密度返回卡片与文字尺寸 */
+const densityClasses = computed(() => {
+  switch (props.density) {
+    case "compact":
+      return {
+        card: "rounded-lg px-2.5 py-2",
+        row: "gap-2",
+        avatar: "h-8 w-8",
+        name: "text-[13px]",
+        meta: "text-[11px]",
+        body: "mt-1.5 text-[13px] leading-5",
+        reply: "mt-1.5 rounded-md px-2.5 py-1.5",
+        replyText: "text-[11px] leading-5",
+        like: "text-[11px]",
+        likeIcon: "size-3",
+      };
+    case "comfortable":
+      return {
+        card: "rounded-2xl px-4 py-3.5",
+        row: "gap-3.5",
+        avatar: "h-10 w-10",
+        name: "text-[15px]",
+        meta: "text-[13px]",
+        body: "mt-2.5 text-[15px] leading-7",
+        reply: "mt-2.5 rounded-lg px-3 py-2.5",
+        replyText: "text-xs leading-5",
+        like: "text-[13px]",
+        likeIcon: "size-4",
+      };
+    default:
+      return {
+        card: "rounded-xl px-3 py-2.5",
+        row: "gap-3",
+        avatar: "h-9 w-9",
+        name: "text-sm",
+        meta: "text-xs",
+        body: "mt-2 text-sm leading-6",
+        reply: "mt-2 rounded-lg px-3 py-2",
+        replyText: "text-xs leading-5",
+        like: "text-xs",
+        likeIcon: "size-3.5",
+      };
+  }
+});
+</script>
+
+<template>
+  <div
+    class="border border-solid transition-colors duration-150"
+    :class="[
+      cover
+        ? 'border-cover/12 bg-gradient-to-br from-cover/10 via-cover/6 to-cover/3 ring-1 ring-cover/5 ring-inset hover:border-cover/20 hover:from-cover/14 hover:via-cover/8'
+        : 'border-primary/20 bg-surface-panel',
+      densityClasses.card,
+    ]"
+  >
+    <div class="flex" :class="densityClasses.row">
+      <SImg
+        v-if="item.avatar"
+        :src="item.avatar"
+        class="shrink-0 rounded-full ring-1"
+        :class="[
+          densityClasses.avatar,
+          cover ? 'ring-cover/15' : 'ring-black/10 dark:ring-white/10',
+        ]"
+        alt=""
+      />
+      <div
+        v-else
+        class="shrink-0 rounded-full"
+        :class="[densityClasses.avatar, cover ? 'bg-cover/10' : 'bg-on-surface/8']"
+      />
+      <div class="min-w-0 flex-1">
+        <div class="flex items-start justify-between gap-3">
+          <div class="min-w-0">
+            <div class="flex items-center gap-1.5">
+              <span class="truncate font-medium" :class="densityClasses.name">
+                {{ item.userName }}
+              </span>
+              <STag
+                v-if="creator"
+                :type="cover ? 'cover' : 'primary'"
+                variant="soft"
+                size="tiny"
+                round
+              >
+                {{ item.creatorName ?? $t("comments.creatorBadge") }}
+              </STag>
+            </div>
+            <div
+              class="mt-0.5 flex gap-2"
+              :class="[densityClasses.meta, cover ? 'text-cover/50' : 'text-on-surface-variant']"
+            >
+              <span v-if="item.time">{{ formatDate(item.time) }}</span>
+              <span v-if="item.location">
+                {{ $t("comments.location", { location: item.location }) }}
+              </span>
+            </div>
+          </div>
+          <div
+            v-if="item.likedCount != null"
+            class="flex shrink-0 items-center gap-1 tabular-nums"
+            :class="[densityClasses.like, cover ? 'text-cover/50' : 'text-on-surface-variant']"
+          >
+            <IconLucideThumbsUp :class="densityClasses.likeIcon" />
+            <span>{{ item.likedCount }}</span>
+          </div>
+        </div>
+        <p class="whitespace-pre-wrap break-words" :class="densityClasses.body">
+          {{ item.text }}
+        </p>
+        <div
+          v-if="item.reply?.length"
+          :class="[densityClasses.reply, cover ? 'bg-cover/7' : 'bg-on-surface/5']"
+        >
+          <div
+            v-for="reply in item.reply"
+            :key="reply.id"
+            class="break-words"
+            :class="[densityClasses.replyText, cover ? 'text-cover/60' : 'text-on-surface-variant']"
+          >
+            <span class="font-medium" :class="cover ? 'text-cover/85' : 'text-on-surface'">
+              {{ reply.userName }}：
+            </span>
+            {{ reply.text }}
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/src/components/comments/CommentList.vue b/src/components/comments/CommentList.vue
new file mode 100644
index 000000000..a9503aa1a
--- /dev/null
+++ b/src/components/comments/CommentList.vue
@@ -0,0 +1,177 @@
+<script setup lang="ts">
+import type { MusicCommentItem } from "@shared/types/comment";
+import type { CommentDensity } from "@shared/types/settings";
+import { layoutMasonry } from "@/utils/commentMasonry";
+import CommentCard from "./CommentCard.vue";
+
+interface Props {
+  /** 评论列表 */
+  items: MusicCommentItem[];
+  /** 最小列宽（px），容器更宽时自动增加列数 */
+  columnMinWidth?: number;
+  /** 主创评论 id 集合，命中时卡片显示主创徽章 */
+  creatorIds?: Set<string>;
+  /** 评论卡片密度 */
+  density?: CommentDensity;
+  /** 是否使用全屏播放器配色 */
+  cover?: boolean;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  columnMinWidth: 280,
+  creatorIds: () => new Set<string>(),
+  density: "standard",
+  cover: false,
+});
+
+const GAPS: Record<CommentDensity, number> = { compact: 8, standard: 12, comfortable: 16 };
+const gap = computed(() => GAPS[props.density]);
+
+const rootRef = ref<HTMLElement | null>(null);
+const itemElements = new Map<string, HTMLElement>();
+const positions = reactive(new Map<string, { x: number; y: number }>());
+const columnWidth = ref(0);
+const containerHeight = ref(0);
+
+let resizeObserver: ResizeObserver | undefined;
+let rootObserver: ResizeObserver | undefined;
+let layoutFrame = 0;
+let layoutToken = 0;
+
+/** 合并同一帧内的多次布局请求 */
+const scheduleLayout = (): void => {
+  if (layoutFrame) return;
+  layoutFrame = requestAnimationFrame(() => {
+    layoutFrame = 0;
+    void runLayout();
+  });
+};
+
+/**
+ * 测量卡片高度并重新计算绝对位置
+ * 列宽变化时先等待 DOM 更新，确保按新宽度测量换行后的高度
+ */
+const runLayout = async (): Promise<void> => {
+  const root = rootRef.value;
+  if (!root) return;
+  const width = root.clientWidth;
+  if (width <= 0) return;
+
+  const token = ++layoutToken;
+  const gapValue = gap.value;
+  const columns = Math.max(1, Math.floor((width + gapValue) / (props.columnMinWidth + gapValue)));
+  const nextColumnWidth = (width - gapValue * (columns - 1)) / columns;
+  if (nextColumnWidth !== columnWidth.value) {
+    columnWidth.value = nextColumnWidth;
+    await nextTick();
+    if (token !== layoutToken) return;
+  }
+
+  const heights = props.items.map((item) => {
+    const element = itemElements.get(item.id);
+    return element ? element.getBoundingClientRect().height : 0;
+  });
+  const layout = layoutMasonry(heights, columns, nextColumnWidth, gapValue);
+
+  positions.clear();
+  props.items.forEach((item, index) => {
+    const position = layout.positions[index];
+    if (position) positions.set(item.id, position);
+  });
+  containerHeight.value = layout.height;
+};
+
+/**
+ * 记录卡片元素引用并触发重新布局
+ * @param id - 评论 id
+ * @param value - 模板 ref 值
+ */
+const setItemRef = (id: string, value: unknown): void => {
+  const element = value instanceof HTMLElement ? value : null;
+  const previous = itemElements.get(id);
+  if (previous === element) return;
+  if (previous) {
+    const content = previous.firstElementChild;
+    if (content) resizeObserver?.unobserve(content);
+    itemElements.delete(id);
+  }
+  if (!element) {
+    positions.delete(id);
+    scheduleLayout();
+    return;
+  }
+  itemElements.set(id, element);
+  const content = element.firstElementChild;
+  if (content) resizeObserver?.observe(content);
+  scheduleLayout();
+};
+
+// 列表变化后清理已移除的卡片并重新排布
+watch(
+  () => props.items,
+  (items) => {
+    const ids = new Set(items.map((item) => item.id));
+    for (const id of positions.keys()) {
+      if (!ids.has(id)) positions.delete(id);
+    }
+    scheduleLayout();
+  },
+  { flush: "post" },
+);
+
+// 密度或最小列宽变化会改变卡片尺寸与列数，DOM 更新后重新测量
+watch([gap, () => props.columnMinWidth], scheduleLayout, { flush: "post" });
+
+onMounted(() => {
+  resizeObserver = new ResizeObserver(() => scheduleLayout());
+  for (const element of itemElements.values()) {
+    const content = element.firstElementChild;
+    if (content) resizeObserver.observe(content);
+  }
+
+  let lastWidth = 0;
+  rootObserver = new ResizeObserver(([entry]) => {
+    if (!entry || Math.abs(entry.contentRect.width - lastWidth) < 0.5) return;
+    lastWidth = entry.contentRect.width;
+    scheduleLayout();
+  });
+  if (rootRef.value) {
+    lastWidth = rootRef.value.clientWidth;
+    rootObserver.observe(rootRef.value);
+  }
+  scheduleLayout();
+});
+
+onBeforeUnmount(() => {
+  layoutToken += 1;
+  cancelAnimationFrame(layoutFrame);
+  resizeObserver?.disconnect();
+  rootObserver?.disconnect();
+  itemElements.clear();
+  positions.clear();
+});
+</script>
+
+<template>
+  <div ref="rootRef" class="relative w-full" :style="{ height: `${containerHeight}px` }">
+    <div
+      v-for="item in items"
+      :key="item.id"
+      :ref="(value) => setItemRef(item.id, value)"
+      class="absolute"
+      :style="{
+        left: `${positions.get(item.id)?.x ?? 0}px`,
+        top: `${positions.get(item.id)?.y ?? 0}px`,
+        width: `${columnWidth}px`,
+        visibility: positions.has(item.id) ? 'visible' : 'hidden',
+      }"
+    >
+      <CommentCard
+        :item="item"
+        :creator="creatorIds.has(item.id)"
+        :density="density"
+        :cover="cover"
+      />
+    </div>
+  </div>
+</template>
diff --git a/src/components/player/FullPlayer/FullPlayerComments.vue b/src/components/player/FullPlayer/FullPlayerComments.vue
new file mode 100644
index 000000000..8fa385c59
--- /dev/null
+++ b/src/components/player/FullPlayer/FullPlayerComments.vue
@@ -0,0 +1,262 @@
+<script setup lang="ts">
+import { useMediaStore } from "@/stores/media";
+import { useSettingsStore } from "@/stores/settings";
+import { useMusicComments } from "@/composables/useMusicComments";
+import CommentList from "@/components/comments/CommentList.vue";
+
+interface Props {
+  /** 展示模式：half 占左半屏窄列，full 全屏多列 */
+  mode: "half" | "full";
+  /** 播放器当前是否处于沉浸状态 */
+  immersive: boolean;
+}
+
+const props = defineProps<Props>();
+const emit = defineEmits<{ close: [] }>();
+
+const { t } = useI18n();
+const media = useMediaStore();
+const settings = useSettingsStore();
+
+const trackRef = computed(() => media.track ?? null);
+const listScrollRef = ref<HTMLElement | null>(null);
+const loadMoreSentinelRef = ref<HTMLElement | null>(null);
+const creatorEnabled = computed(() => settings.system.comments.creatorEnabled);
+const comments = useMusicComments(trackRef, listScrollRef, creatorEnabled);
+
+const {
+  sources,
+  sourceId,
+  activeTab,
+  creatorComments,
+  creatorIds,
+  creatorLoading,
+  creatorError,
+  loading,
+  page,
+  sourceOptions,
+  tabs,
+  dedupedList,
+  error,
+  loadMore,
+  refresh,
+  retry,
+  retryCreator,
+} = comments;
+
+const commentsDensity = computed(() => settings.system.comments.density);
+const columnMinWidth = computed(() => {
+  const base = props.mode === "half" ? 400 : 360;
+  if (commentsDensity.value === "compact") return base - 40;
+  if (commentsDensity.value === "comfortable") return base + 40;
+  return base;
+});
+const artistNames = computed(() => media.track?.artists.map((artist) => artist.name).join(" / "));
+const scrolling = ref(false);
+let loadMoreObserver: IntersectionObserver | undefined;
+let scrollTimer: ReturnType<typeof setTimeout> | undefined;
+
+/** 通知父组件关闭评论区 */
+const handleClose = (): void => emit("close");
+
+/** 滚动时短暂显示滚动条，静止后再隐去 */
+const handleScroll = (): void => {
+  scrolling.value = true;
+  clearTimeout(scrollTimer);
+  scrollTimer = setTimeout(() => {
+    scrolling.value = false;
+  }, 700);
+};
+
+onMounted(() => {
+  loadMoreObserver = new IntersectionObserver(
+    ([entry]) => {
+      if (entry?.isIntersecting) void loadMore();
+    },
+    { root: listScrollRef.value, rootMargin: "0px 0px 400px", threshold: 0 },
+  );
+  if (loadMoreSentinelRef.value) loadMoreObserver.observe(loadMoreSentinelRef.value);
+});
+
+// 列表高度变化后哨兵可能仍在视口内，重新观察以触发下一次加载
+watch(
+  () => [activeTab.value, loading.value, page.value.list.length] as const,
+  async () => {
+    await nextTick();
+    const sentinel = loadMoreSentinelRef.value;
+    if (!sentinel || !loadMoreObserver) return;
+    loadMoreObserver.unobserve(sentinel);
+    loadMoreObserver.observe(sentinel);
+  },
+);
+
+onBeforeUnmount(() => {
+  loadMoreObserver?.disconnect();
+  clearTimeout(scrollTimer);
+});
+</script>
+
+<template>
+  <div class="flex h-full flex-col text-cover">
+    <div class="shrink-0 flex items-start justify-between gap-4 pl-1 pb-4">
+      <div class="flex min-w-0 items-center gap-3 pl-2.5">
+        <SImg
+          v-if="media.track?.cover"
+          :src="media.track.cover"
+          class="size-12 shrink-0 rounded-lg"
+          alt=""
+        />
+        <div v-else class="size-12 shrink-0 rounded-lg bg-cover/14" />
+        <div class="min-w-0">
+          <h2 class="m-0 truncate text-2xl font-semibold leading-tight">
+            {{ t("comments.name") }}
+          </h2>
+          <div class="mt-1 flex min-w-0 items-center gap-2 text-sm text-cover/55">
+            <span class="truncate">{{ media.track?.title }}</span>
+            <span v-if="artistNames" class="shrink-0 text-cover/25">·</span>
+            <span v-if="artistNames" class="truncate">{{ artistNames }}</span>
+          </div>
+        </div>
+      </div>
+      <div
+        class="shrink-0 flex items-center gap-3 transition-opacity duration-400"
+        :class="immersive ? 'opacity-0 pointer-events-none' : 'opacity-100'"
+      >
+        <SButton
+          type="cover"
+          variant="secondary"
+          round
+          :size="40"
+          :loading="loading"
+          @click="refresh"
+        >
+          <template #icon><IconLucideRefreshCw /></template>
+        </SButton>
+        <SButton type="cover" variant="secondary" round :size="40" @click="handleClose">
+          <template #icon><IconLucideX /></template>
+        </SButton>
+      </div>
+    </div>
+
+    <div class="shrink-0 flex items-center gap-4 pl-3 pb-3">
+      <div class="min-w-0 flex-1">
+        <STabs v-model="activeTab" :tabs="tabs" type="bar" size="medium" cover />
+      </div>
+      <div
+        class="w-32 shrink-0 transition-opacity duration-400"
+        :class="immersive ? 'opacity-0 pointer-events-none' : 'opacity-100'"
+      >
+        <SSelect
+          v-model="sourceId"
+          :options="sourceOptions"
+          :disabled="sources.length === 0 || loading"
+          cover
+        />
+      </div>
+    </div>
+
+    <div
+      class="relative min-h-0 flex-1"
+      :style="{
+        maskImage:
+          'linear-gradient(180deg, transparent 0px, #000 24px, #000 calc(100% - 32px), transparent 100%)',
+      }"
+    >
+      <div
+        ref="listScrollRef"
+        class="h-full overflow-y-auto pl-3 pr-2 pt-6 pb-8 [scrollbar-gutter:stable] [&::-webkit-scrollbar-thumb]:bg-cover/25 [&::-webkit-scrollbar-thumb:hover]:bg-cover/45"
+        :class="immersive && !scrolling ? '[&::-webkit-scrollbar-thumb]:bg-transparent' : ''"
+        @scroll="handleScroll"
+      >
+        <div v-if="creatorLoading && !creatorComments.length" class="mb-6">
+          <div class="mb-3 flex items-center gap-2">
+            <span class="h-4 w-0.5 rounded-full bg-cover/70" />
+            <h3 class="m-0 text-sm font-semibold text-cover/85">{{ t("comments.creator") }}</h3>
+          </div>
+          <div class="grid grid-cols-2 gap-3">
+            <div v-for="n in 4" :key="n" class="h-20 rounded-xl bg-cover/8 animate-pulse" />
+          </div>
+        </div>
+        <div v-else-if="creatorComments.length" class="mb-6">
+          <div class="mb-3 flex items-center gap-2">
+            <span class="h-4 w-0.5 rounded-full bg-cover/70" />
+            <h3 class="m-0 text-sm font-semibold text-cover/85">{{ t("comments.creator") }}</h3>
+          </div>
+          <CommentList
+            :items="creatorComments"
+            :creator-ids="creatorIds"
+            :column-min-width="columnMinWidth"
+            :density="commentsDensity"
+            cover
+          />
+        </div>
+        <div v-else-if="creatorError" class="mb-6">
+          <div class="mb-3 flex items-center gap-2">
+            <span class="h-4 w-0.5 rounded-full bg-cover/70" />
+            <h3 class="m-0 text-sm font-semibold text-cover/85">{{ t("comments.creator") }}</h3>
+          </div>
+          <div class="flex flex-col items-start gap-2">
+            <p class="m-0 text-sm text-cover/55">{{ creatorError }}</p>
+            <SButton size="small" type="cover" variant="outline" @click="retryCreator">
+              {{ t("common.retry") }}
+            </SButton>
+          </div>
+        </div>
+
+        <div
+          v-if="!sources.length && !error"
+          class="flex min-h-64 items-center justify-center text-cover/35"
+        >
+          <div class="text-center">
+            <IconLucideMessageCircleOff class="mx-auto mb-4 size-14 opacity-30" />
+            <div class="text-sm">{{ t("comments.noSource") }}</div>
+          </div>
+        </div>
+        <div
+          v-else-if="error && !dedupedList.length"
+          class="flex min-h-64 flex-col items-center justify-center gap-3"
+        >
+          <div class="text-sm text-cover/55">{{ error }}</div>
+          <SButton type="cover" variant="outline" @click="retry">
+            {{ t("common.retry") }}
+          </SButton>
+        </div>
+        <div
+          v-else-if="!dedupedList.length && loading"
+          class="flex min-h-64 items-center justify-center text-cover/35"
+        >
+          <div class="text-center">
+            <SLoading class="mx-auto mb-4 block text-4xl text-cover/50" />
+            <div class="text-sm">{{ t("comments.loading") }}</div>
+          </div>
+        </div>
+        <div
+          v-else-if="!dedupedList.length"
+          class="flex min-h-64 items-center justify-center text-cover/35"
+        >
+          <div class="text-center">
+            <IconLucideMessageCircleOff class="mx-auto mb-4 size-14 opacity-30" />
+            <div class="text-sm">{{ t("comments.empty") }}</div>
+          </div>
+        </div>
+        <CommentList
+          v-else
+          :items="dedupedList"
+          :column-min-width="columnMinWidth"
+          :density="commentsDensity"
+          cover
+        />
+
+        <div ref="loadMoreSentinelRef" class="h-px" />
+        <div v-if="page.loadingMore" class="flex justify-center py-5 text-cover/55">
+          <SLoading class="text-2xl" />
+        </div>
+        <div v-else-if="page.appendError" class="flex justify-center py-5">
+          <SButton size="small" type="cover" variant="outline" @click="loadMore">
+            {{ t("common.retry") }}
+          </SButton>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/src/components/player/FullPlayer/index.vue b/src/components/player/FullPlayer/index.vue
index 88b34bfc1..afae7f41a 100644
--- a/src/components/player/FullPlayer/index.vue
+++ b/src/components/player/FullPlayer/index.vue
@@ -12,6 +12,7 @@ import { useImmersiveMode } from "@/composables/useImmersiveMode";
 import { useTimeFormat } from "@/composables/useTimeFormat";
 import { useProgressLyric } from "@/composables/useProgressLyric";
 import Lyrics from "@/components/player/Lyrics/index.vue";
+import FullPlayerComments from "./FullPlayerComments.vue";
 import { useWindowControls } from "@/composables/useWindowControls";
 import * as player from "@/core/player";
 import { playerTransitionActive, setPlayerExpanded } from "@/services/playerTransition";
@@ -191,10 +192,17 @@ const fullscreenCover = computed(() => settings.player.coverLayout === "fullscre
 const coverWidth = computed(() => `${settings.player.coverLyricRatio * 100}%`);
 
 const coverCentered = computed(() => {
-  if (fullscreenCover.value || status.fullQueueOpen) return false;
+  if (fullscreenCover.value || status.fullQueueOpen || status.fullCommentsOpen) return false;
   return !showLyric.value || (settings.player.autoCenterCover && !hasLyric.value);
 });
 
+/** 全屏内嵌评论布局：off 关闭、half 左半屏、full 全屏 */
+const fullCommentMode = computed<"off" | "half" | "full">(() => {
+  if (!status.fullCommentsOpen) return "off";
+  // 以实际就绪的歌词判定，避免歌词加载中导致面板宽度反复切换
+  return media.parsedLyric.length > 0 && showLyric.value ? "half" : "full";
+});
+
 const handleLyricSeek = async (timeMs: number): Promise<void> => {
   await player.seek(timeMs);
   if (!isPlaying.value) await player.play();
@@ -259,10 +267,6 @@ const toggleLyric = (): void => {
     showLyric.value = !showLyric.value;
   }
 };
-
-const showComments = (): void => {
-  if (displayTrack.value) status.showComments(displayTrack.value);
-};
 </script>
 
 <template>
@@ -290,9 +294,19 @@ const showComments = (): void => {
         <!-- 背景 -->
         <PlayerBackground :visible="playerVisible" :active="visualizerMounted" />
         <!-- 全屏封面 -->
-        <div v-if="fullscreenCover" class="absolute inset-y-0 left-0 w-[60%]">
-          <PlayerCover fullscreen />
-        </div>
+        <Transition
+          enter-active-class="transition-opacity duration-250"
+          enter-from-class="opacity-0"
+          leave-active-class="transition-opacity duration-250"
+          leave-to-class="opacity-0"
+        >
+          <div
+            v-if="fullscreenCover && fullCommentMode === 'off'"
+            class="absolute inset-y-0 left-0 w-[60%]"
+          >
+            <PlayerCover fullscreen />
+          </div>
+        </Transition>
         <!-- 底部频谱 -->
         <BottomSpectrum
           v-if="isPlayerExpanded && visualizerMounted && settings.player.enableSpectrum"
@@ -300,12 +314,12 @@ const showComments = (): void => {
         />
         <!-- 顶/底栏渐变遮罩（全屏封面模式） -->
         <div
-          v-if="fullscreenCover"
+          v-if="fullscreenCover && fullCommentMode === 'off'"
           class="cover-mask-top absolute top-0 inset-x-0 h-20 z-5 pointer-events-none transition-opacity duration-400"
           :class="immersive ? 'opacity-0' : 'opacity-100'"
         />
         <div
-          v-if="fullscreenCover"
+          v-if="fullscreenCover && fullCommentMode === 'off'"
           class="cover-mask-bottom absolute bottom-0 inset-x-0 h-48 z-5 pointer-events-none transition-opacity duration-400"
           :class="immersive ? 'opacity-0' : 'opacity-100'"
         />
@@ -344,7 +358,8 @@ const showComments = (): void => {
           <!-- 左侧 -->
           <div
             v-if="!fullscreenCover"
-            class="absolute inset-y-0 left-0 flex items-center justify-center px-12 transition-transform duration-600 ease-[cubic-bezier(0.4,0,0.2,1)]"
+            class="absolute inset-y-0 left-0 flex items-center justify-center px-12 transition-[transform,opacity] duration-600 ease-[cubic-bezier(0.4,0,0.2,1)]"
+            :class="fullCommentMode === 'off' ? 'opacity-100' : 'opacity-0 pointer-events-none'"
             :style="{
               width: coverWidth,
               transform: coverCentered ? 'translateX(calc(50vw - 50%))' : undefined,
@@ -365,20 +380,27 @@ const showComments = (): void => {
           <div
             class="group absolute inset-y-0 right-0 pr-20 flex flex-col transition-opacity duration-600 ease-[cubic-bezier(0.4,0,0.2,1)]"
             :class="
-              coverCentered || status.fullQueueOpen
+              coverCentered || status.fullQueueOpen || fullCommentMode === 'full'
                 ? 'opacity-0 pointer-events-none'
                 : 'opacity-100'
             "
             :style="{ width: fullscreenCover ? '50%' : `calc(100% - ${coverWidth})` }"
           >
             <!-- 全屏封面 -->
-            <div
-              v-if="fullscreenCover"
-              class="shrink-0 pt-2 pb-6 pl-[calc(1em-0.5rem)]"
-              :style="{ fontSize: lyricFontSize }"
+            <Transition
+              enter-active-class="transition-opacity duration-250"
+              enter-from-class="opacity-0"
+              leave-active-class="transition-opacity duration-250"
+              leave-to-class="opacity-0"
             >
-              <PlayerData align="left" simple />
-            </div>
+              <div
+                v-if="fullscreenCover && fullCommentMode === 'off'"
+                class="shrink-0 pt-2 pb-6 pl-[calc(1em-0.5rem)]"
+                :style="{ fontSize: lyricFontSize }"
+              >
+                <PlayerData align="left" simple />
+              </div>
+            </Transition>
             <!-- 歌词容器 -->
             <div
               class="lyric-area relative flex-1 min-h-0"
@@ -414,6 +436,30 @@ const showComments = (): void => {
             <!-- 歌词侧边工具栏 -->
             <LyricActions :immersive="immersive" />
           </div>
+          <!-- 全屏内嵌评论 -->
+          <Transition
+            enter-active-class="transition-opacity duration-250 ease-[cubic-bezier(0.4,0,0.2,1)]"
+            enter-from-class="opacity-0"
+            leave-active-class="transition-opacity duration-250 ease-[cubic-bezier(0.4,0,0.2,1)]"
+            leave-to-class="opacity-0"
+          >
+            <div
+              v-if="fullCommentMode !== 'off'"
+              class="absolute py-4 z-6 transition-[inset,width,padding] duration-250 ease-[cubic-bezier(0.4,0,0.2,1)]"
+              :class="
+                fullCommentMode === 'half'
+                  ? 'inset-y-0 left-0 pl-[clamp(32px,4vw,64px)] pr-[clamp(20px,2.5vw,40px)]'
+                  : 'inset-0 w-full px-[clamp(32px,5vw,80px)]'
+              "
+              :style="fullCommentMode === 'half' ? { width: coverWidth } : undefined"
+            >
+              <FullPlayerComments
+                :mode="fullCommentMode"
+                :immersive="immersive"
+                @close="status.toggleFullComments"
+              />
+            </div>
+          </Transition>
           <!-- 播放队列 -->
           <div
             class="absolute inset-y-0 right-0 pl-4 py-6 flex items-center"
@@ -467,11 +513,11 @@ const showComments = (): void => {
             </SButton>
             <SButton
               type="cover"
-              variant="ghost"
+              :variant="status.fullCommentsOpen ? 'tertiary' : 'ghost'"
               size="large"
               circle
               :disabled="!hasTrack"
-              @click="showComments"
+              @click="status.toggleFullComments"
             >
               <template #icon><IconLucideMessageCircle /></template>
             </SButton>
diff --git a/src/components/ui/SSelect.vue b/src/components/ui/SSelect.vue
index 6a3bd2657..85d3981ce 100644
--- a/src/components/ui/SSelect.vue
+++ b/src/components/ui/SSelect.vue
@@ -16,6 +16,8 @@ export interface SSelectProps {
   placeholder?: string;
   /** 全圆角胶囊形 */
   round?: boolean;
+  /** 使用全屏播放器配色 */
+  cover?: boolean;
 }
 
 const props = withDefaults(defineProps<SSelectProps>(), {
@@ -23,6 +25,7 @@ const props = withDefaults(defineProps<SSelectProps>(), {
   disabled: false,
   placeholder: "",
   round: false,
+  cover: false,
 });
 
 const emit = defineEmits<{
@@ -49,15 +52,21 @@ const handleChange = (val: string) => {
     @update:open="onOpenChange"
   >
     <SelectTrigger
-      class="group flex w-full items-center justify-between gap-2 h-8.5 px-3 text-sm text-on-surface bg-field border border-solid border-on-surface/20 cursor-pointer outline-none focus-visible:outline-none transition-[border-color,box-shadow,opacity] duration-250 hover:border-on-surface/50 data-[state=open]:border-primary data-[state=open]:ring-2 data-[state=open]:ring-primary/25 disabled:opacity-50 disabled:cursor-not-allowed overflow-hidden"
-      :class="round ? 'rounded-full' : 'rounded-lg'"
+      class="group flex w-full items-center justify-between gap-2 h-8.5 px-3 text-sm border border-solid cursor-pointer outline-none focus-visible:outline-none transition-[border-color,background-color,box-shadow,opacity] duration-250 disabled:opacity-50 disabled:cursor-not-allowed overflow-hidden"
+      :class="[
+        round ? 'rounded-full' : 'rounded-lg',
+        cover
+          ? 'text-cover bg-cover/8 border-cover/15 hover:bg-cover/12 hover:border-cover/25 data-[state=open]:border-cover/35 data-[state=open]:ring-2 data-[state=open]:ring-cover/10'
+          : 'text-on-surface bg-field border-on-surface/20 hover:border-on-surface/50 data-[state=open]:border-primary data-[state=open]:ring-2 data-[state=open]:ring-primary/25',
+      ]"
     >
       <SelectValue class="min-w-0 truncate">
         <span class="truncate">{{ selectedLabel }}</span>
       </SelectValue>
       <SelectIcon as-child>
         <IconLucideChevronDown
-          class="size-3.5 text-on-surface-variant/50 shrink-0 transition-transform duration-200 group-data-[state=open]:rotate-180"
+          class="size-3.5 shrink-0 transition-transform duration-200 group-data-[state=open]:rotate-180"
+          :class="cover ? 'text-cover/50' : 'text-on-surface-variant/50'"
         />
       </SelectIcon>
     </SelectTrigger>
diff --git a/src/components/ui/STabs.vue b/src/components/ui/STabs.vue
index 65ec500fe..36f5584ce 100644
--- a/src/components/ui/STabs.vue
+++ b/src/components/ui/STabs.vue
@@ -24,6 +24,8 @@ export interface STabsProps {
   animated?: boolean;
   /** 圆角胶囊 */
   round?: boolean;
+  /** 使用全屏播放器配色 */
+  cover?: boolean;
 }
 
 const props = withDefaults(defineProps<STabsProps>(), {
@@ -31,6 +33,7 @@ const props = withDefaults(defineProps<STabsProps>(), {
   size: "medium",
   animated: false,
   round: false,
+  cover: false,
 });
 
 const emit = defineEmits<{
@@ -216,15 +219,19 @@ const panelTransitionClasses = computed(() => {
       type === 'bar' && (justifyContent ? 'flex w-full pb-1' : 'inline-flex shrink-0 gap-3 pb-1'),
     ]"
   >
-    <div v-if="type === 'line'" class="absolute inset-x-0 bottom-0 h-0.5 bg-outline-variant/65" />
+    <div
+      v-if="type === 'line'"
+      class="absolute inset-x-0 bottom-0 h-0.5"
+      :class="cover ? 'bg-cover/15' : 'bg-outline-variant/65'"
+    />
 
     <div
       v-if="indicatorStyle.width"
       :class="[
         'absolute pointer-events-none transition-[left,width] duration-320 ease-[cubic-bezier(0.4,0,0.2,1)]',
         type === 'segment'
-          ? ['bg-primary/12', round ? 'rounded-full' : 'rounded-md']
-          : 'bottom-0.5 h-[3px] bg-primary rounded-full',
+          ? [cover ? 'bg-cover/14' : 'bg-primary/12', round ? 'rounded-full' : 'rounded-md']
+          : [cover ? 'bg-cover' : 'bg-primary', 'bottom-0.5 h-[3px] rounded-full'],
       ]"
       :style="indicatorStyle"
     />
@@ -241,16 +248,20 @@ const panelTransitionClasses = computed(() => {
         type === 'segment' ? ['flex-1 h-full', segmentTabClasses[size]] : sizeClasses[size],
         tab.disabled ? 'opacity-40 cursor-not-allowed' : 'cursor-pointer',
         modelValue === tab.key
-          ? {
-              bar: 'text-primary font-medium',
-              line: 'text-primary font-medium',
-              segment: 'text-on-surface font-medium',
-            }[type]
-          : {
-              bar: 'text-on-surface-variant',
-              line: 'text-on-surface-variant',
-              segment: 'text-on-surface',
-            }[type],
+          ? cover
+            ? 'text-cover font-medium'
+            : {
+                bar: 'text-primary font-medium',
+                line: 'text-primary font-medium',
+                segment: 'text-on-surface font-medium',
+              }[type]
+          : cover
+            ? 'text-cover/55 hover:text-cover/75'
+            : {
+                bar: 'text-on-surface-variant',
+                line: 'text-on-surface-variant',
+                segment: 'text-on-surface',
+              }[type],
       ]"
       @click="select(tab)"
     >
diff --git a/src/composables/useMusicComments.spec.ts b/src/composables/useMusicComments.spec.ts
new file mode 100644
index 000000000..6d319a016
--- /dev/null
+++ b/src/composables/useMusicComments.spec.ts
@@ -0,0 +1,139 @@
+import { effectScope, nextTick, ref, type Ref } from "vue";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { Track } from "@shared/types/player";
+
+type CreatorResult = { ok: true; data: never[] } | { ok: false; error: string };
+
+const api = vi.hoisted(() => ({
+  sources: vi.fn(async () => [{ id: "builtin:netease", name: "网易云", kind: "builtin" }]),
+  get: vi.fn(),
+  creator: vi.fn<() => Promise<CreatorResult>>(async () => ({ ok: true, data: [] })),
+}));
+
+vi.stubGlobal("window", { api: { comments: api } });
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+vi.mock("@/composables/useToast", () => ({ toast: { error: vi.fn() } }));
+
+const { useMusicComments } = await import("./useMusicComments");
+
+const track = (id: string): Track => ({
+  id,
+  source: "netease",
+  title: `歌名${id}`,
+  artists: [],
+  duration: 0,
+});
+
+const pageOf = (ids: string[], overrides: Record<string, unknown> = {}) => ({
+  list: ids.map((id) => ({ id, userName: id, text: id })),
+  total: ids.length,
+  page: 1,
+  limit: 20,
+  hasMore: false,
+  ...overrides,
+});
+
+/**
+ * 在独立作用域内运行 composable，便于统一销毁
+ * @param trackRef - 曲目引用
+ * @returns 作用域内的返回值与销毁函数
+ */
+const setup = (trackRef: Ref<Track | null>, creatorEnabled = true) => {
+  const scope = effectScope();
+  const result = scope.run(() =>
+    useMusicComments(trackRef, ref<HTMLElement | null>(null), ref(creatorEnabled)),
+  )!;
+  return { ...result, stop: () => scope.stop() };
+};
+
+/**
+ * 等待初始加载链路完成
+ * @returns 无
+ */
+const settle = async (): Promise<void> => {
+  for (let round = 0; round < 5; round++) {
+    await Promise.resolve();
+    await nextTick();
+  }
+};
+
+describe("评论数据层", () => {
+  beforeEach(() => {
+    api.sources.mockClear();
+    api.get.mockReset();
+    api.creator.mockClear();
+    api.get.mockResolvedValue({ ok: true, data: pageOf(["1", "2"]) });
+  });
+
+  it("请求进行中切换曲目后丢弃过期响应", async () => {
+    let resolveFirst!: (value: unknown) => void;
+    api.get
+      .mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            resolveFirst = resolve;
+          }),
+      )
+      .mockResolvedValue({ ok: true, data: pageOf(["9"]) });
+
+    const trackRef = ref<Track | null>(track("a"));
+    const comments = setup(trackRef);
+    trackRef.value = track("b");
+    await settle();
+    resolveFirst({ ok: true, data: pageOf(["1", "2"]) });
+    await settle();
+
+    expect(comments.page.value.list.map((entry) => entry.id)).toEqual(["9"]);
+    comments.stop();
+  });
+
+  it("追加时带上已保存的游标", async () => {
+    api.get
+      .mockResolvedValueOnce({ ok: true, data: pageOf(["1"], { hasMore: true, nextCursor: "c1" }) })
+      .mockResolvedValue({ ok: true, data: pageOf(["2"], { hasMore: false }) });
+    const trackRef = ref<Track | null>(track("a"));
+    const comments = setup(trackRef);
+    await settle();
+    await comments.loadMore();
+    const lastCall = api.get.mock.calls.at(-1)?.[0];
+    expect(lastCall?.cursor).toBe("c1");
+    expect(lastCall?.page).toBe(2);
+    comments.stop();
+  });
+
+  it("主创说关闭时不请求主创接口", async () => {
+    const trackRef = ref<Track | null>(track("a"));
+    const comments = setup(trackRef, false);
+    await settle();
+    expect(api.creator).not.toHaveBeenCalled();
+    expect(comments.creatorComments.value).toEqual([]);
+    comments.stop();
+  });
+
+  it("主创说失败时写入错误并可重试", async () => {
+    api.creator.mockResolvedValueOnce({ ok: false, error: "boom" });
+    api.creator.mockResolvedValue({ ok: true, data: [] });
+    const trackRef = ref<Track | null>(track("a"));
+    const comments = setup(trackRef);
+    await settle();
+    expect(comments.creatorError.value).toBe("boom");
+    await comments.retryCreator();
+    expect(comments.creatorError.value).toBe("");
+    comments.stop();
+  });
+
+  it("热评为空而最新非空时切换到最新", async () => {
+    api.get.mockImplementation(async (args: { type: string }) => ({
+      ok: true,
+      data:
+        args.type === "hot"
+          ? { list: [], total: 0, page: 1, limit: 20, hasMore: false }
+          : { list: [{ id: "1", userName: "u", text: "t" }], total: 1, page: 1, limit: 20 },
+    }));
+    const trackRef = ref<Track | null>(track("a"));
+    const comments = setup(trackRef);
+    await settle();
+    expect(comments.activeTab.value).toBe("new");
+    comments.stop();
+  });
+});
diff --git a/src/composables/useMusicComments.ts b/src/composables/useMusicComments.ts
new file mode 100644
index 000000000..d97f46694
--- /dev/null
+++ b/src/composables/useMusicComments.ts
@@ -0,0 +1,335 @@
+import type { Ref } from "vue";
+import type { Track } from "@shared/types/player";
+import type {
+  CommentSource,
+  CommentTab,
+  MusicCommentItem,
+  MusicCommentPage,
+} from "@shared/types/comment";
+import { toast } from "@/composables/useToast";
+import { appendUniqueComments, hasNextCommentPage } from "@/utils/commentPagination";
+
+const DEFAULT_LIMIT = 20;
+const NETEASE_SOURCE_ID = "builtin:netease";
+
+type CommentTabState = MusicCommentPage & {
+  hasMore: boolean;
+  loadingMore: boolean;
+  initialError: string;
+  appendError: string;
+};
+
+/**
+ * 构造空的评论分页状态
+ * @returns 尚未加载任何数据的分页状态
+ */
+const createTabState = (): CommentTabState => ({
+  list: [],
+  total: 0,
+  page: 0,
+  limit: DEFAULT_LIMIT,
+  hasMore: true,
+  loadingMore: false,
+  initialError: "",
+  appendError: "",
+});
+
+/**
+ * 生成曲目身份键，用于判断请求期间是否已切换曲目
+ * @param track - 曲目
+ * @returns 曲目身份键
+ */
+const makeTrackKey = (track: Track): string =>
+  `${track.source}\n${track.serverId ?? ""}\n${track.id}`;
+
+/**
+ * 生成曲目与评论源组成的上下文键
+ * @param track - 曲目
+ * @param source - 评论源 id
+ * @returns 上下文键
+ */
+const makeContextKey = (track: Track, source: string): string =>
+  `${makeTrackKey(track)}\n${source}`;
+
+/**
+ * 歌曲评论数据加载
+ * 四个作废层共同保证迟到的响应不会覆盖新的曲目、来源或分页状态
+ * @param trackRef - 当前曲目引用，通常为全屏播放器当前播放曲目
+ * @param scrollRef - 评论滚动容器
+ * @param creatorEnabled - 是否加载主创说
+ */
+export const useMusicComments = (
+  trackRef: Ref<Track | null>,
+  scrollRef: Ref<HTMLElement | null>,
+  creatorEnabled: Ref<boolean>,
+) => {
+  const { t } = useI18n();
+
+  const sources = shallowRef<CommentSource[]>([]);
+  const sourceId = ref("");
+  const activeTab = ref<CommentTab>("hot");
+  const loadingCount = ref(0);
+  const sourceError = ref("");
+
+  const pages = reactive<Record<CommentTab, CommentTabState>>({
+    hot: createTabState(),
+    new: createTabState(),
+  });
+  const requestTokens = reactive<Record<CommentTab, number>>({ hot: 0, new: 0 });
+
+  const creatorComments = shallowRef<MusicCommentItem[]>([]);
+  const creatorLoading = ref(false);
+  const creatorError = ref("");
+
+  let loadingEpoch = 0;
+  let creatorEpoch = 0;
+  let disposed = false;
+
+  const sourceOptions = computed(() =>
+    sources.value.map((source) => ({ value: source.id, label: source.name })),
+  );
+  const tabs = computed(() => [
+    { key: "hot", label: `${t("comments.hot")} (${pages.hot.total})` },
+    { key: "new", label: `${t("comments.new")} (${pages.new.total})` },
+  ]);
+
+  const loading = computed(() => loadingCount.value > 0);
+  const page = computed(() => pages[activeTab.value]);
+  const error = computed(() => sourceError.value || page.value.initialError);
+  const creatorIds = computed(() => new Set(creatorComments.value.map((comment) => comment.id)));
+  const dedupedList = computed(() =>
+    page.value.list.filter((item) => !creatorIds.value.has(item.id)),
+  );
+
+  /** 加载可用评论源，失败时记录错误供界面重试 */
+  const loadSources = async (): Promise<void> => {
+    try {
+      const available = await window.api.comments.sources();
+      if (disposed) return;
+      sources.value = available;
+      sourceError.value = "";
+      if (!available.some((source) => source.id === sourceId.value)) {
+        sourceId.value = available[0]?.id ?? "";
+      }
+    } catch (err) {
+      if (disposed) return;
+      sources.value = [];
+      sourceError.value = err instanceof Error ? err.message : String(err);
+    }
+  };
+
+  /** 重置分页与主创数据，并作废所有进行中的请求 */
+  const resetPages = (): void => {
+    requestTokens.hot += 1;
+    requestTokens.new += 1;
+    creatorEpoch += 1;
+    loadingEpoch += 1;
+    loadingCount.value = 0;
+    pages.hot = createTabState();
+    pages.new = createTabState();
+    creatorComments.value = [];
+    creatorLoading.value = false;
+    creatorError.value = "";
+  };
+
+  /**
+   * 加载指定分类的评论
+   * @param type - 评论分类
+   * @param pageNo - 页码，从 1 开始
+   * @param append - 是否追加到现有列表
+   */
+  const loadPage = async (type: CommentTab, pageNo = 1, append = false): Promise<void> => {
+    const track = trackRef.value;
+    if (!track || !sourceId.value) return;
+
+    const token = requestTokens[type] + 1;
+    requestTokens[type] = token;
+    const contextKey = makeContextKey(track, sourceId.value);
+    const epoch = loadingEpoch;
+    const state = pages[type];
+
+    if (append) {
+      state.loadingMore = true;
+      state.appendError = "";
+    } else {
+      loadingCount.value += 1;
+      state.initialError = "";
+    }
+
+    const isCurrentRequest = (): boolean => {
+      const currentTrack = trackRef.value;
+      return (
+        !disposed &&
+        requestTokens[type] === token &&
+        loadingEpoch === epoch &&
+        !!currentTrack &&
+        makeContextKey(currentTrack, sourceId.value) === contextKey
+      );
+    };
+
+    try {
+      const result = await window.api.comments.get({
+        sourceId: sourceId.value,
+        track: toRaw(track),
+        type,
+        page: pageNo,
+        limit: state.limit,
+        cursor: append ? (state.nextCursor ?? undefined) : undefined,
+      });
+      if (!result.ok) throw new Error(result.error);
+      if (!isCurrentRequest()) return;
+
+      const previousCount = state.list.length;
+      const nextList = append
+        ? appendUniqueComments(state.list, result.data.list)
+        : result.data.list;
+      pages[type] = {
+        ...result.data,
+        list: nextList,
+        hasMore:
+          hasNextCommentPage(result.data, nextList.length) &&
+          (!append || nextList.length > previousCount),
+        loadingMore: false,
+        initialError: "",
+        appendError: "",
+      };
+    } catch (err) {
+      if (!isCurrentRequest()) return;
+      const message = err instanceof Error ? err.message : String(err);
+      if (append) {
+        pages[type].appendError = message;
+      } else {
+        pages[type].initialError = message;
+        toast.error(message);
+      }
+    } finally {
+      if (isCurrentRequest()) {
+        if (append) pages[type].loadingMore = false;
+        else loadingCount.value = Math.max(0, loadingCount.value - 1);
+      }
+    }
+  };
+
+  /** 加载当前分类的下一页 */
+  const loadMore = async (): Promise<void> => {
+    const state = pages[activeTab.value];
+    if (loading.value || state.loadingMore || !state.hasMore || state.page < 1) return;
+    await loadPage(activeTab.value, state.page + 1, true);
+  };
+
+  /** 加载主创说评论，仅网易云内建源可用 */
+  const loadCreator = async (): Promise<void> => {
+    const track = trackRef.value;
+    if (!creatorEnabled.value || !track || sourceId.value !== NETEASE_SOURCE_ID) {
+      creatorComments.value = [];
+      creatorError.value = "";
+      return;
+    }
+    const epoch = ++creatorEpoch;
+    creatorLoading.value = true;
+    creatorError.value = "";
+    try {
+      const result = await window.api.comments.creator({
+        sourceId: sourceId.value,
+        track: toRaw(track),
+      });
+      if (epoch !== creatorEpoch) return;
+      if (!result.ok) throw new Error(result.error);
+      creatorComments.value = result.data;
+    } catch (err) {
+      if (epoch !== creatorEpoch) return;
+      creatorError.value = err instanceof Error ? err.message : String(err);
+      creatorComments.value = [];
+    } finally {
+      if (epoch === creatorEpoch) creatorLoading.value = false;
+    }
+  };
+
+  /** 重试主创说加载 */
+  const retryCreator = async (): Promise<void> => {
+    creatorError.value = "";
+    await loadCreator();
+  };
+
+  /** 刷新两组评论与主创说 */
+  const refresh = async (): Promise<void> => {
+    resetPages();
+    const requests = [loadPage("hot"), loadPage("new")];
+    if (creatorEnabled.value) requests.push(loadCreator());
+    await Promise.all(requests);
+    // 小众歌曲可能没有热门评论，自动落到最新评论避免开局空状态
+    if (
+      activeTab.value === "hot" &&
+      pages.hot.total === 0 &&
+      pages.hot.initialError === "" &&
+      pages.new.total > 0
+    ) {
+      activeTab.value = "new";
+    }
+    await nextTick();
+    scrollRef.value?.scrollTo({ top: 0 });
+  };
+
+  /** 统一重试：评论源加载失败时先重新加载源 */
+  const retry = async (): Promise<void> => {
+    if (sourceError.value) {
+      await loadSources();
+      if (!sourceError.value) await refresh();
+      return;
+    }
+    await loadPage(activeTab.value, 1);
+  };
+
+  watch(trackRef, (next, previous) => {
+    if (!next || (previous && makeTrackKey(next) === makeTrackKey(previous))) return;
+    void refresh();
+  });
+
+  watch(sourceId, (next, previous) => {
+    if (!next || !previous || next === previous) return;
+    void refresh();
+  });
+
+  watch(creatorEnabled, (enabled) => {
+    if (enabled) {
+      void loadCreator();
+      return;
+    }
+    creatorEpoch += 1;
+    creatorLoading.value = false;
+    creatorComments.value = [];
+    creatorError.value = "";
+  });
+
+  void loadSources().then(async () => {
+    if (!disposed && !sourceError.value) await refresh();
+  });
+
+  onScopeDispose(() => {
+    disposed = true;
+    requestTokens.hot += 1;
+    requestTokens.new += 1;
+    creatorEpoch += 1;
+    loadingEpoch += 1;
+  });
+
+  return {
+    sources,
+    sourceId,
+    activeTab,
+    creatorComments,
+    creatorLoading,
+    creatorError,
+    loading,
+    page,
+    sourceOptions,
+    tabs,
+    creatorIds,
+    dedupedList,
+    error,
+    loadMore,
+    refresh,
+    retry,
+    retryCreator,
+  };
+};
diff --git a/src/i18n/locales/en-US.json b/src/i18n/locales/en-US.json
index bd48c5af9..731771277 100644
--- a/src/i18n/locales/en-US.json
+++ b/src/i18n/locales/en-US.json
@@ -137,6 +137,8 @@
     "empty": "No comments yet",
     "noSource": "No comment source available",
     "location": "From {location}",
+    "creator": "Creator Says",
+    "creatorBadge": "Creator",
     "page": "Page {page} / {total}"
   },
   "equalizer": {
@@ -805,6 +807,7 @@
       "database": "Database Management",
       "backupReset": "Backup & Reset",
       "debug": "Debug",
+      "comments": "Comments",
       "preset": "OCD Settings",
       "envInfo": "Environment Info"
     },
@@ -862,6 +865,17 @@
       "label": "Show Subtitle",
       "description": "Show alias and other subtitle info in song list"
     },
+    "creatorComments": {
+      "label": "Creator Says",
+      "description": "Show comments from the song's creators; enabling this adds extra API requests and caches creator comments"
+    },
+    "commentDensity": {
+      "label": "Comment Density",
+      "description": "Control spacing, font size and avatar size of comment cards in the player",
+      "compact": "Compact",
+      "standard": "Standard",
+      "comfortable": "Comfortable"
+    },
     "rememberLastTrack": {
       "label": "Remember Progress",
       "description": "Restore playback position on startup"
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index 532c60ef8..c84b48390 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -137,6 +137,8 @@
     "empty": "暂无评论",
     "noSource": "没有可用的评论来源",
     "location": "来自{location}",
+    "creator": "主创说",
+    "creatorBadge": "主创",
     "page": "第 {page} / {total} 页"
   },
   "equalizer": {
@@ -805,6 +807,7 @@
       "downloadTags": "写入内容",
       "backupReset": "备份与重置",
       "debug": "调试",
+      "comments": "评论",
       "preset": "强迫症配置",
       "envInfo": "环境信息"
     },
@@ -862,6 +865,17 @@
       "label": "显示副标题",
       "description": "歌曲列表中显示别名等副标题信息"
     },
+    "creatorComments": {
+      "label": "主创说",
+      "description": "在评论区展示歌曲主创的发言，开启后会产生额外的接口请求并缓存主创评论"
+    },
+    "commentDensity": {
+      "label": "评论密度",
+      "description": "控制播放器内评论卡片的间距、字号与头像尺寸",
+      "compact": "紧凑",
+      "standard": "标准",
+      "comfortable": "宽松"
+    },
     "rememberLastTrack": {
       "label": "记忆播放进度",
       "description": "启动时恢复上次歌曲的播放进度"
diff --git a/src/settings/categories/other.ts b/src/settings/categories/other.ts
index 9fdf9929e..6611547a2 100644
--- a/src/settings/categories/other.ts
+++ b/src/settings/categories/other.ts
@@ -62,6 +62,28 @@ const otherCategory: SettingCategory = {
         },
       ],
     },
+    {
+      id: "comments",
+      items: [
+        {
+          key: "creatorComments",
+          type: "switch",
+          binding: { store: "settings", path: "system.comments.creatorEnabled" },
+          defaultValue: false,
+        },
+        {
+          key: "commentDensity",
+          type: "select",
+          binding: { store: "settings", path: "system.comments.density" },
+          options: [
+            { value: "compact", labelKey: "settings.commentDensity.compact" },
+            { value: "standard", labelKey: "settings.commentDensity.standard" },
+            { value: "comfortable", labelKey: "settings.commentDensity.comfortable" },
+          ],
+          defaultValue: "standard",
+        },
+      ],
+    },
     {
       id: "preset",
       items: [
diff --git a/src/stores/status.ts b/src/stores/status.ts
index d22ba1750..8273a5d1b 100644
--- a/src/stores/status.ts
+++ b/src/stores/status.ts
@@ -44,6 +44,8 @@ export const useStatusStore = defineStore(
     const commentsTrack = shallowRef<Track | null>(null);
     /** 音频输出信息弹窗状态 */
     const audioInfoOpen = ref(false);
+    /** 全屏播放器内嵌评论开关 */
+    const fullCommentsOpen = ref(false);
     /** 全屏播放器是否展示歌词 */
     const showLyric = ref(true);
     /** 当前播放索引 */
@@ -132,12 +134,23 @@ export const useStatusStore = defineStore(
     /** 当前队列项对应的播放来源上下文 */
     const currentPlaybackContext = computed(() => queue.getQueueItem(playIndex.value)?.context);
 
-    /** 打开指定歌曲评论 */
+    /** 打开指定歌曲评论弹窗 */
     const showComments = (track: Track): void => {
       commentsTrack.value = track;
       commentsOpen.value = true;
     };
 
+    /** 切换全屏播放器内嵌评论，与播放队列互斥 */
+    const toggleFullComments = (): void => {
+      if (fullQueueOpen.value) fullQueueOpen.value = false;
+      fullCommentsOpen.value = !fullCommentsOpen.value;
+    };
+
+    // 播放队列打开时收起评论，覆盖所有打开队列的入口
+    watch(fullQueueOpen, (open) => {
+      if (open) fullCommentsOpen.value = false;
+    });
+
     return {
       state,
       position,
@@ -156,7 +169,10 @@ export const useStatusStore = defineStore(
       searchOpen,
       commentsOpen,
       commentsTrack,
+      showComments,
       audioInfoOpen,
+      fullCommentsOpen,
+      toggleFullComments,
       showLyric,
       outputDevices,
       playIndex,
@@ -181,7 +197,6 @@ export const useStatusStore = defineStore(
       currentTrack,
       currentIndex,
       currentPlaybackContext,
-      showComments,
     };
   },
   {
diff --git a/src/utils/commentMasonry.spec.ts b/src/utils/commentMasonry.spec.ts
new file mode 100644
index 000000000..9a5a16ba2
--- /dev/null
+++ b/src/utils/commentMasonry.spec.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { layoutMasonry } from "./commentMasonry";
+
+describe("瀑布流布局", () => {
+  it("单列时纵向间距恒定", () => {
+    const { positions, height } = layoutMasonry([100, 50, 80], 1, 300, 12);
+    expect(positions).toEqual([
+      { x: 0, y: 0 },
+      { x: 0, y: 112 },
+      { x: 0, y: 174 },
+    ]);
+    expect(positions[1].y - (positions[0].y + 100)).toBe(12);
+    expect(positions[2].y - (positions[1].y + 50)).toBe(12);
+    expect(height).toBe(254);
+  });
+
+  it("优先放入最矮的列", () => {
+    const { positions } = layoutMasonry([100, 80, 40], 2, 200, 10);
+    expect(positions[0]).toEqual({ x: 0, y: 0 });
+    expect(positions[1]).toEqual({ x: 210, y: 0 });
+    expect(positions[2]).toEqual({ x: 210, y: 90 });
+  });
+
+  it("容器高度不包含末尾间距", () => {
+    expect(layoutMasonry([100], 1, 300, 12).height).toBe(100);
+  });
+
+  it("列数至少为一且空列表高度为零", () => {
+    expect(layoutMasonry([10], 0, 300, 12).positions[0]).toEqual({ x: 0, y: 0 });
+    expect(layoutMasonry([], 2, 300, 12)).toEqual({ positions: [], height: 0 });
+  });
+});
diff --git a/src/utils/commentMasonry.ts b/src/utils/commentMasonry.ts
new file mode 100644
index 000000000..adbcb225f
--- /dev/null
+++ b/src/utils/commentMasonry.ts
@@ -0,0 +1,41 @@
+/** 瀑布流卡片位置 */
+export interface MasonryPosition {
+  x: number;
+  y: number;
+}
+
+/** 瀑布流布局结果 */
+export interface MasonryLayout {
+  positions: MasonryPosition[];
+  height: number;
+}
+
+/**
+ * 将卡片依次放入当前最矮的列，保证同列上下间距恒定
+ * @param heights - 每张卡片的实际高度
+ * @param columns - 列数
+ * @param columnWidth - 列宽
+ * @param gap - 卡片间距
+ * @returns 每张卡片的位置与容器总高度
+ */
+export const layoutMasonry = (
+  heights: number[],
+  columns: number,
+  columnWidth: number,
+  gap: number,
+): MasonryLayout => {
+  const columnCount = Math.max(1, columns);
+  const columnHeights = new Array<number>(columnCount).fill(0);
+  const positions = heights.map((height) => {
+    let target = 0;
+    for (let index = 1; index < columnCount; index += 1) {
+      if (columnHeights[index] < columnHeights[target]) target = index;
+    }
+    const y = Math.round(columnHeights[target]);
+    const x = Math.round(target * (columnWidth + gap));
+    columnHeights[target] = y + Math.max(0, height) + gap;
+    return { x, y };
+  });
+  const height = Math.max(0, Math.ceil(Math.max(...columnHeights) - gap));
+  return { positions, height };
+};
diff --git a/src/utils/commentPagination.spec.ts b/src/utils/commentPagination.spec.ts
new file mode 100644
index 000000000..1e81211b1
--- /dev/null
+++ b/src/utils/commentPagination.spec.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import type { MusicCommentItem } from "@shared/types/comment";
+import { appendUniqueComments, hasNextCommentPage } from "./commentPagination";
+
+const item = (id: string): MusicCommentItem => ({ id, userName: id, text: id });
+
+const pageOf = (list: MusicCommentItem[], total: number, limit = 20, hasMore?: boolean) => ({
+  list,
+  total,
+  page: 1,
+  limit,
+  ...(hasMore === undefined ? {} : { hasMore }),
+});
+
+describe("评论追加去重", () => {
+  it("对既有与新增内部都去重且保序", () => {
+    const merged = appendUniqueComments(
+      [item("1"), item("2")],
+      [item("2"), item("3"), item("3"), item("1"), item("4")],
+    );
+    expect(merged.map((entry) => entry.id)).toEqual(["1", "2", "3", "4"]);
+  });
+});
+
+describe("评论下一页判定", () => {
+  it("显式 hasMore 优先于总数推断", () => {
+    expect(hasNextCommentPage(pageOf([item("1")], 100, 20, true), 1)).toBe(true);
+    expect(hasNextCommentPage(pageOf([item("1")], 100, 20, false), 1)).toBe(false);
+  });
+
+  it("满页且已加载数小于总数时继续", () => {
+    const list = Array.from({ length: 20 }, (_, index) => item(String(index)));
+    expect(hasNextCommentPage(pageOf(list, 40), 20)).toBe(true);
+  });
+
+  it("短页时结束", () => {
+    expect(hasNextCommentPage(pageOf([item("1")], 40), 1)).toBe(false);
+  });
+
+  it("总数未知时满页继续翻页", () => {
+    const list = Array.from({ length: 20 }, (_, index) => item(String(index)));
+    expect(hasNextCommentPage(pageOf(list, 0), 20)).toBe(true);
+  });
+});
diff --git a/src/utils/commentPagination.ts b/src/utils/commentPagination.ts
new file mode 100644
index 000000000..5faf947ba
--- /dev/null
+++ b/src/utils/commentPagination.ts
@@ -0,0 +1,28 @@
+import type { MusicCommentItem, MusicCommentPage } from "@shared/types/comment";
+
+/**
+ * 合并两段评论并去重，保持先后顺序
+ * @param current - 已加载的评论
+ * @param incoming - 新一页评论
+ * @returns 去重合并后的评论列表
+ */
+export const appendUniqueComments = (
+  current: readonly MusicCommentItem[],
+  incoming: readonly MusicCommentItem[],
+): MusicCommentItem[] => {
+  const ids = new Set(current.map((item) => item.id));
+  return [...current, ...incoming.filter((item) => !ids.has(item.id) && Boolean(ids.add(item.id)))];
+};
+
+/**
+ * 判断评论是否还有下一页
+ * 来源给出 hasMore 时以其为准，否则用本页条数与已知总数推断
+ * @param page - 本次返回的分页数据
+ * @param loadedCount - 去重合并后的已加载总数
+ * @returns 是否还有下一页
+ */
+export const hasNextCommentPage = (page: MusicCommentPage, loadedCount: number): boolean => {
+  if (page.hasMore !== undefined) return page.hasMore;
+  if (page.list.length < page.limit) return false;
+  return page.total <= 0 || loadedCount < page.total;
+};