diff --git a/app/api/settings/route.ts b/app/api/settings/route.ts
index a0c7883..cbf727f 100644
--- a/app/api/settings/route.ts
+++ b/app/api/settings/route.ts
@@ -1,6 +1,6 @@
 import { auth } from '@/auth';
 import { query } from '@/lib/db';
-import { DEFAULT_FONT_ID, isFontId, type FontId } from '@/lib/fonts';
+import { DEFAULT_FONT_ID, getStoredFontFamily, parseStoredFontFamily } from '@/lib/fonts';
 import { logRouteOutcome, type LogFields } from '@/lib/log';
 import { getRequestId, jsonResponse, PRIVATE_NO_STORE, readContentLength } from '@/lib/request';
 import { LIMITS, validateSettingsRequest } from '@/lib/validation';
@@ -17,7 +17,7 @@ type SettingsPatch = {
   systemPrompt: string | null;
   saveHistory: boolean | null;
   girlMode: boolean | null;
-  font: FontId | null;
+  fontFamily: string | null;
   keyJwk: string | null;
 };
 
@@ -80,7 +80,7 @@ async function upsertSettingsRow(email: string, patch: SettingsPatch): Promise<{
           key_jwk       = COALESCE($4, user_settings.key_jwk),
           girl_mode     = COALESCE($5, user_settings.girl_mode),
           font_family   = COALESCE($6, user_settings.font_family)`,
-      [email, patch.systemPrompt, patch.saveHistory, patch.keyJwk, patch.girlMode, patch.font],
+      [email, patch.systemPrompt, patch.saveHistory, patch.keyJwk, patch.girlMode, patch.fontFamily],
     );
     return { legacySchema: false, hasFontColumn: true };
   } catch (error) {
@@ -152,8 +152,7 @@ export async function GET(req: Request) {
     ctx.user = session.user.email;
 
     const { row, legacySchema, hasFontColumn } = await getSettingsRow(session.user.email);
-    const savedFont = row?.font_family ?? null;
-    const font = savedFont && isFontId(savedFont) ? savedFont : DEFAULT_FONT_ID;
+    const { font, customFontFamily } = parseStoredFontFamily(row?.font_family ?? null);
     ctx.status = 200;
     ctx.hasKey = !!row?.key_jwk;
     ctx.saveHistory = row?.save_history ?? false;
@@ -166,6 +165,7 @@ export async function GET(req: Request) {
       systemPrompt: row?.system_prompt ?? '',
       saveHistory: row?.save_history ?? false,
       font,
+      customFontFamily,
       ...(legacySchema ? {} : { girlMode: row?.girl_mode ?? false }),
       keyJwk: row?.key_jwk ?? null,
     }, {}, { requestId, cacheControl: PRIVATE_NO_STORE });
@@ -242,7 +242,9 @@ export async function PUT(req: Request) {
       systemPrompt: hasOwn(input, 'systemPrompt') ? parsed.value.systemPrompt : null,
       saveHistory: hasOwn(input, 'saveHistory') ? parsed.value.saveHistory : null,
       girlMode: hasOwn(input, 'girlMode') ? parsed.value.girlMode : null,
-      font: hasOwn(input, 'font') ? parsed.value.font : null,
+      fontFamily: hasOwn(input, 'font') || hasOwn(input, 'customFontFamily')
+        ? getStoredFontFamily(parsed.value.font, parsed.value.customFontFamily)
+        : null,
       keyJwk: hasOwn(input, 'keyJwk') ? parsed.value.keyJwk : null,
     };
 
@@ -250,13 +252,13 @@ export async function PUT(req: Request) {
     ctx.keyJwkChars = patch.keyJwk === null ? ctx.keyJwkChars : patch.keyJwk.length;
     ctx.saveHistory = patch.saveHistory;
     ctx.girlMode = patch.girlMode;
-    ctx.font = patch.font;
+    ctx.font = patch.fontFamily;
     ctx.hasKey = patch.keyJwk === null ? null : patch.keyJwk.length > 0;
 
     const { legacySchema, hasFontColumn } = await upsertSettingsRow(session.user.email, patch);
     ctx.status = 204;
     ctx.girlMode = legacySchema ? null : patch.girlMode;
-    ctx.font = hasFontColumn ? patch.font : null;
+    ctx.font = hasFontColumn ? patch.fontFamily : null;
     ctx.hasFontColumn = hasFontColumn;
     ctx.legacySchema = legacySchema;
     return new Response(null, {
diff --git a/app/layout.tsx b/app/layout.tsx
index 740c804..ec81eb0 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -1,8 +1,15 @@
 import type { Metadata, Viewport } from 'next';
+import { IBM_Plex_Mono, JetBrains_Mono } from 'next/font/google';
 import './globals.css';
 import 'highlight.js/styles/atom-one-dark.min.css';
+import { CUSTOM_FONT_ID, DEFAULT_FONT_FAMILY, FONTS } from '@/lib/fonts';
 
 const GIRL_MODE_STORAGE_KEY = 'gippidy-girl-mode';
+const FONT_STORAGE_KEY = 'gippidy-font';
+const CUSTOM_FONT_STORAGE_KEY = 'gippidy-custom-font-family';
+const jetbrainsMono = JetBrains_Mono({ subsets: ['latin'], variable: '--font-jetbrains-mono', display: 'swap' });
+const ibmPlexMono = IBM_Plex_Mono({ subsets: ['latin'], weight: ['400', '500', '700'], variable: '--font-ibm-plex-mono', display: 'swap' });
+const FONT_BOOTSTRAP_MAP = Object.fromEntries(FONTS.map(font => [font.id, font.family]));
 const GIRL_MODE_BOOTSTRAP = `
 try {
   if (localStorage.getItem('${GIRL_MODE_STORAGE_KEY}') === '1') {
@@ -10,6 +17,21 @@ try {
   }
 } catch {}
 `;
+const FONT_BOOTSTRAP = `
+try {
+  const fontMap = ${JSON.stringify(FONT_BOOTSTRAP_MAP)};
+  const defaultFont = ${JSON.stringify(DEFAULT_FONT_FAMILY)};
+  const font = localStorage.getItem('${FONT_STORAGE_KEY}');
+  const custom = (localStorage.getItem('${CUSTOM_FONT_STORAGE_KEY}') || '')
+    .replace(/[{};]/g, ' ')
+    .replace(/\\s+/g, ' ')
+    .trim();
+  const value = font === '${CUSTOM_FONT_ID}'
+    ? (custom ? custom + ', monospace' : defaultFont)
+    : (font && fontMap[font]) || defaultFont;
+  document.documentElement.style.setProperty('--app-font-family', value);
+} catch {}
+`;
 
 export const metadata: Metadata = {
   metadataBase: new URL(process.env.NEXT_PUBLIC_BASE_URL ?? 'https://www.gippidy.chat'),
@@ -25,9 +47,9 @@ export const viewport: Viewport = {
 
 export default function RootLayout({ children }: { children: React.ReactNode }) {
   return (
-    <html lang="en" suppressHydrationWarning>
+    <html lang="en" suppressHydrationWarning className={`${jetbrainsMono.variable} ${ibmPlexMono.variable}`}>
       <body>
-        <script dangerouslySetInnerHTML={{ __html: GIRL_MODE_BOOTSTRAP }} />
+        <script dangerouslySetInnerHTML={{ __html: `${GIRL_MODE_BOOTSTRAP}\n${FONT_BOOTSTRAP}` }} />
         {children}
       </body>
     </html>
diff --git a/app/page.tsx b/app/page.tsx
index 4fef68c..da9b604 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -5,7 +5,7 @@ import { signOut } from 'next-auth/react';
 import RenderedMarkdown from './rendered-markdown';
 import { renderMarkdown } from '@/lib/markdown';
 import { getOrCreateKey, encrypt, decrypt } from '@/lib/crypto';
-import { DEFAULT_FONT_ID, FONTS, getFontFamily, isFontId, type FontId } from '@/lib/fonts';
+import { CUSTOM_FONT_ID, DEFAULT_FONT_ID, FONTS, getFontFamily, isFontId, normalizeCustomFontFamily, type FontId } from '@/lib/fonts';
 import { DEFAULT_MODEL_ID, getModelLabel, MODELS, normalizeModelId } from '@/lib/models';
 import { splitMessageFollowups, type Role, type Image, type Pdf, type Message } from '@/lib/chat';
 import { LIMITS } from '@/lib/validation';
@@ -16,6 +16,7 @@ type PendingPdf  = Pdf;
 const MODEL_KEY    = 'gippidy-model';
 const KEY_WARNED   = 'gippidy-key-warned';
 const FONT_KEY     = 'gippidy-font';
+const CUSTOM_FONT_FAMILY_KEY = 'gippidy-custom-font-family';
 const GIRL_MODE_KEY = 'gippidy-girl-mode';
 const ACTIVE_HISTORY_CHAT_KEY = 'gippidy-active-history-chat';
 const HISTORY_PREVIEW_CACHE_KEY = 'gippidy-history-preview-cache';
@@ -52,7 +53,14 @@ type HistoryRestoreResult =
   | { kind: 'ok'; item: HistoryItem }
   | { kind: 'missing' }
   | { kind: 'error' };
-type SettingsPatch = { systemPrompt?: string; saveHistory?: boolean; girlMode?: boolean; font?: FontId; keyJwk?: string | null };
+type SettingsPatch = {
+  systemPrompt?: string;
+  saveHistory?: boolean;
+  girlMode?: boolean;
+  font?: FontId;
+  customFontFamily?: string;
+  keyJwk?: string | null;
+};
 type PendingSettings = Omit<SettingsPatch, 'keyJwk'>;
 
 function withRenderedHtml(message: Message): Message {
@@ -128,8 +136,8 @@ function setGirlModeDom(enabled: boolean) {
   else document.documentElement.removeAttribute(GIRL_MODE_ATTR);
 }
 
-function setFontDom(font: FontId) {
-  document.documentElement.style.setProperty('--app-font-family', getFontFamily(font));
+function setFontDom(font: FontId, customFontFamily?: string) {
+  document.documentElement.style.setProperty('--app-font-family', getFontFamily(font, customFontFamily));
 }
 
 function isBuiltInDefaultSystemPrompt(prompt: string): boolean {
@@ -253,6 +261,7 @@ export default function Home() {
   const [saveHistory, setSaveHistory]           = useState(false);
   const [girlMode, setGirlMode]                 = useState(false);
   const [font, setFont]                         = useState<FontId>(DEFAULT_FONT_ID);
+  const [customFontFamily, setCustomFontFamily] = useState('');
   const [showHistory, setShowHistory]           = useState(false);
   const [historyItems, setHistoryItems]         = useState<HistoryPreview[]>([]);
   const [historyLoading, setHistoryLoading]     = useState(false);
@@ -292,6 +301,7 @@ export default function Home() {
   const saveHistoryRef  = useRef(saveHistory);
   const girlModeRef     = useRef(girlMode);
   const fontRef         = useRef(font);
+  const customFontFamilyRef = useRef(customFontFamily);
   const chatStateVersionRef = useRef(0);
   const initialSettingsLoadedRef = useRef(false);
   const pendingSettingsRef = useRef<PendingSettings>({});
@@ -314,6 +324,10 @@ export default function Home() {
     fontRef.current = font;
   }, [font]);
 
+  useEffect(() => {
+    customFontFamilyRef.current = customFontFamily;
+  }, [customFontFamily]);
+
   useEffect(() => () => {
     if (saveSettingsTimer.current) clearTimeout(saveSettingsTimer.current);
     if (streamingHtmlTimerRef.current) clearTimeout(streamingHtmlTimerRef.current);
@@ -387,11 +401,16 @@ export default function Home() {
     setGirlModeDom(enabled);
   };
 
-  const applyFont = (nextFont: FontId) => {
+  const applyFont = (nextFont: FontId, nextCustomFontFamily = customFontFamilyRef.current) => {
+    const normalizedCustomFontFamily = normalizeCustomFontFamily(nextCustomFontFamily);
     fontRef.current = nextFont;
+    customFontFamilyRef.current = normalizedCustomFontFamily;
     setFont(nextFont);
+    setCustomFontFamily(normalizedCustomFontFamily);
     localStorage.setItem(FONT_KEY, nextFont);
-    setFontDom(nextFont);
+    if (normalizedCustomFontFamily) localStorage.setItem(CUSTOM_FONT_FAMILY_KEY, normalizedCustomFontFamily);
+    else localStorage.removeItem(CUSTOM_FONT_FAMILY_KEY);
+    setFontDom(nextFont, normalizedCustomFontFamily);
   };
 
   const applyModel = (nextModel: string, source: 'localStorage' | 'fork' | 'history' | 'selection') => {
@@ -631,8 +650,13 @@ export default function Home() {
   useEffect(() => {
     const saved = localStorage.getItem(MODEL_KEY);
     if (saved) applyModel(saved, 'localStorage');
+    const savedCustomFontFamily = normalizeCustomFontFamily(localStorage.getItem(CUSTOM_FONT_FAMILY_KEY));
     const savedFont = localStorage.getItem(FONT_KEY);
-    if (savedFont && isFontId(savedFont)) applyFont(savedFont);
+    if (savedFont && isFontId(savedFont)) applyFont(savedFont, savedCustomFontFamily);
+    else if (savedCustomFontFamily) {
+      customFontFamilyRef.current = savedCustomFontFamily;
+      setCustomFontFamily(savedCustomFontFamily);
+    }
     const savedGirlMode = localStorage.getItem(GIRL_MODE_KEY);
     const activeHistoryChatId = localStorage.getItem(ACTIVE_HISTORY_CHAT_KEY);
     if (savedGirlMode === '1' || savedGirlMode === '0') {
@@ -675,10 +699,11 @@ export default function Home() {
         if (!r.ok) throw new Error(`settings_get_${r.status}`);
         return r.json();
       })
-      .then(async ({ systemPrompt, saveHistory: sh, girlMode: gm, font: fo, keyJwk }) => {
+      .then(async ({ systemPrompt, saveHistory: sh, girlMode: gm, font: fo, customFontFamily: cff, keyJwk }) => {
         const pending = pendingSettingsRef.current;
         const nextSaveHistory = pending.saveHistory ?? Boolean(sh);
         const nextGirlMode = pending.girlMode ?? forkGirlModeOverrideRef.current ?? (typeof gm === 'boolean' ? gm : girlModeRef.current);
+        const nextCustomFontFamily = pending.customFontFamily ?? normalizeCustomFontFamily(cff ?? customFontFamilyRef.current);
         const nextFont = pending.font ?? (isFontId(fo) ? fo : fontRef.current);
         const rawSystemPrompt = pending.systemPrompt ?? (systemPrompt ?? '');
         const nextSystemPrompt = resolveDefaultSystemPrompt(rawSystemPrompt, nextGirlMode);
@@ -692,7 +717,7 @@ export default function Home() {
         saveHistoryRef.current = nextSaveHistory;
         setSaveHistory(nextSaveHistory);
         applyGirlMode(nextGirlMode);
-        applyFont(nextFont);
+        applyFont(nextFont, nextCustomFontFamily);
         // Load or create the encryption key (shared across all deployments via DB)
         const { key, jwk } = await getOrCreateKey(keyJwk ?? null);
         cryptoKeyRef.current = key;
@@ -810,8 +835,25 @@ export default function Home() {
       return;
     }
     applyFont(nextFont);
-    rememberPendingSettings({ font: nextFont });
-    persistSettings({ font: nextFont }, true);
+    rememberPendingSettings({ font: nextFont, customFontFamily: customFontFamilyRef.current });
+    persistSettings({ font: nextFont, customFontFamily: customFontFamilyRef.current }, true);
+  };
+
+  const handleCustomFontFamilyChange = (nextCustomFontFamily: string) => {
+    const normalizedCustomFontFamily = normalizeCustomFontFamily(nextCustomFontFamily);
+    customFontFamilyRef.current = normalizedCustomFontFamily;
+    setCustomFontFamily(normalizedCustomFontFamily);
+    if (normalizedCustomFontFamily) localStorage.setItem(CUSTOM_FONT_FAMILY_KEY, normalizedCustomFontFamily);
+    else localStorage.removeItem(CUSTOM_FONT_FAMILY_KEY);
+
+    if (fontRef.current === CUSTOM_FONT_ID) {
+      applyFont(CUSTOM_FONT_ID, normalizedCustomFontFamily);
+      rememberPendingSettings({ font: CUSTOM_FONT_ID, customFontFamily: normalizedCustomFontFamily });
+      persistSettings({ font: CUSTOM_FONT_ID, customFontFamily: normalizedCustomFontFamily }, true);
+      return;
+    }
+
+    rememberPendingSettings({ customFontFamily: normalizedCustomFontFamily });
   };
 
   const handleToggleSaveHistory = (val: boolean) => {
@@ -1321,8 +1363,20 @@ export default function Home() {
               {FONTS.map(option => (
                 <option key={option.id} value={option.id}>{option.label}</option>
               ))}
+              <option value={CUSTOM_FONT_ID}>Custom font stack</option>
             </select>
           </div>
+          {font === CUSTOM_FONT_ID && (
+            <div className="settings-row">
+              <label>Custom Font</label>
+              <input
+                type="text"
+                value={customFontFamily}
+                onChange={e => handleCustomFontFamilyChange(e.target.value)}
+                placeholder="e.g. Berkeley Mono, Menlo, monospace"
+              />
+            </div>
+          )}
           <div className="settings-row">
             <label>System Prompt</label>
             <textarea
diff --git a/lib/fonts.ts b/lib/fonts.ts
index 0125250..5edad2d 100644
--- a/lib/fonts.ts
+++ b/lib/fonts.ts
@@ -1,21 +1,56 @@
+export const CUSTOM_FONT_ID = 'custom' as const;
+
 export const FONTS = [
   { id: 'courier-new', label: 'Courier New', family: "'Courier New', Courier, monospace" },
   { id: 'menlo', label: 'Menlo', family: "Menlo, Monaco, 'Courier New', monospace" },
   { id: 'consolas', label: 'Consolas', family: "Consolas, 'Liberation Mono', 'Courier New', monospace" },
   { id: 'monaco', label: 'Monaco', family: "Monaco, Menlo, 'Courier New', monospace" },
+  { id: 'jetbrains-mono', label: 'JetBrains Mono', family: "var(--font-jetbrains-mono), 'Courier New', monospace" },
+  { id: 'ibm-plex-mono', label: 'IBM Plex Mono', family: "var(--font-ibm-plex-mono), 'Courier New', monospace" },
 ] as const;
 
-export type FontId = (typeof FONTS)[number]['id'];
+export type BuiltInFontId = (typeof FONTS)[number]['id'];
+export type FontId = BuiltInFontId | typeof CUSTOM_FONT_ID;
 
-export const DEFAULT_FONT_ID: FontId = FONTS[0].id;
+export const DEFAULT_FONT_ID: BuiltInFontId = FONTS[0].id;
 export const DEFAULT_FONT_FAMILY = FONTS[0].family;
-export const ALLOWED_FONTS = new Set<string>(FONTS.map(font => font.id));
+export const ALLOWED_FONTS = new Set<FontId>([...FONTS.map(font => font.id), CUSTOM_FONT_ID]);
 
 export function isFontId(value: string): value is FontId {
-  return ALLOWED_FONTS.has(value);
+  return ALLOWED_FONTS.has(value as FontId);
+}
+
+export function isBuiltInFontId(value: string): value is BuiltInFontId {
+  return FONTS.some(candidate => candidate.id === value);
+}
+
+export function normalizeCustomFontFamily(value: string | null | undefined): string {
+  return (value ?? '')
+    .replace(/[{};]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 200);
 }
 
-export function getFontFamily(fontId: string | null | undefined): string {
+export function getFontFamily(fontId: string | null | undefined, customFontFamily?: string | null): string {
+  if (fontId === CUSTOM_FONT_ID) {
+    const custom = normalizeCustomFontFamily(customFontFamily);
+    return custom ? `${custom}, monospace` : DEFAULT_FONT_FAMILY;
+  }
   const font = FONTS.find(candidate => candidate.id === fontId);
   return font?.family ?? DEFAULT_FONT_FAMILY;
 }
+
+export function parseStoredFontFamily(value: string | null | undefined): { font: FontId; customFontFamily: string } {
+  const normalized = normalizeCustomFontFamily(value);
+  if (!normalized) return { font: DEFAULT_FONT_ID, customFontFamily: '' };
+  if (isBuiltInFontId(normalized)) return { font: normalized, customFontFamily: '' };
+  return { font: CUSTOM_FONT_ID, customFontFamily: normalized };
+}
+
+export function getStoredFontFamily(font: FontId, customFontFamily?: string | null): string {
+  if (font === CUSTOM_FONT_ID) {
+    return normalizeCustomFontFamily(customFontFamily) || DEFAULT_FONT_ID;
+  }
+  return isBuiltInFontId(font) ? font : DEFAULT_FONT_ID;
+}
diff --git a/lib/validation.ts b/lib/validation.ts
index 81e576e..fb35fa8 100644
--- a/lib/validation.ts
+++ b/lib/validation.ts
@@ -1,5 +1,5 @@
 import type { Image, Message, Pdf, Role } from './chat';
-import { DEFAULT_FONT_ID, isFontId, type FontId } from './fonts';
+import { DEFAULT_FONT_ID, isFontId, normalizeCustomFontFamily, type FontId } from './fonts';
 import { isModelId } from './models';
 
 type ValidationResult<T> =
@@ -24,6 +24,7 @@ export const LIMITS = {
   maxTextFileBytes: 500_000,
   maxPdfNameChars: 200,
   maxSystemPromptChars: 20_000,
+  maxCustomFontFamilyChars: 200,
   maxJwkChars: 8_000,
   maxIvChars: 256,
   maxCiphertextBytes: 6_000_000,
@@ -166,6 +167,7 @@ export function validateSettingsRequest(input: unknown): ValidationResult<{
   saveHistory: boolean;
   girlMode: boolean;
   font: FontId;
+  customFontFamily: string;
   keyJwk: string | null;
 }> {
   if (!isPlainObject(input)) return fail('invalid request body');
@@ -177,6 +179,10 @@ export function validateSettingsRequest(input: unknown): ValidationResult<{
   if (input.girlMode !== undefined && typeof input.girlMode !== 'boolean') return fail('invalid girlMode');
   if (input.font !== undefined && typeof input.font !== 'string') return fail('invalid font');
   if (typeof input.font === 'string' && !isFontId(input.font)) return fail('invalid font');
+  if (input.customFontFamily !== undefined && typeof input.customFontFamily !== 'string') return fail('invalid customFontFamily');
+  if (typeof input.customFontFamily === 'string' && input.customFontFamily.length > LIMITS.maxCustomFontFamilyChars) {
+    return fail('customFontFamily too large', 413);
+  }
   if (input.keyJwk !== undefined && input.keyJwk !== null && typeof input.keyJwk !== 'string') return fail('invalid keyJwk');
   if (typeof input.keyJwk === 'string') {
     if (input.keyJwk.length > LIMITS.maxJwkChars) return fail('keyJwk too large', 413);
@@ -193,6 +199,7 @@ export function validateSettingsRequest(input: unknown): ValidationResult<{
     saveHistory: input.saveHistory ?? false,
     girlMode: input.girlMode ?? false,
     font: typeof input.font === 'string' ? input.font : DEFAULT_FONT_ID,
+    customFontFamily: normalizeCustomFontFamily(typeof input.customFontFamily === 'string' ? input.customFontFamily : ''),
     keyJwk: typeof input.keyJwk === 'string' ? input.keyJwk : null,
   });
 }
diff --git a/tests/unit.test.ts b/tests/unit.test.ts
index 21d52dd..f29ef38 100644
--- a/tests/unit.test.ts
+++ b/tests/unit.test.ts
@@ -1043,6 +1043,11 @@ test('validateSettingsRequest: validates and defaults girlMode and font', () =>
     source.includes("font: typeof input.font === 'string' ? input.font : DEFAULT_FONT_ID,"),
     'validateSettingsRequest should default the saved font to the app default when none is supplied',
   );
+  assert.ok(
+    source.includes("if (input.customFontFamily !== undefined && typeof input.customFontFamily !== 'string') return fail('invalid customFontFamily');") &&
+      source.includes("customFontFamily: normalizeCustomFontFamily(typeof input.customFontFamily === 'string' ? input.customFontFamily : ''),"),
+    'validateSettingsRequest should normalize the advanced custom font stack field',
+  );
 });
 
 test('settings persistence preserves untouched fields and tolerates older schemas', () => {
@@ -1091,6 +1096,10 @@ test('page source merges local settings changes before initial settings hydrate
     source.includes("const nextFont = pending.font ?? (isFontId(fo) ? fo : fontRef.current);"),
     'page should keep a local font choice instead of overwriting it with stale server data',
   );
+  assert.ok(
+    source.includes("const nextCustomFontFamily = pending.customFontFamily ?? normalizeCustomFontFamily(cff ?? customFontFamilyRef.current);"),
+    'page should keep a local custom font stack instead of overwriting it with stale server data',
+  );
   assert.ok(
     source.includes('pendingPersistRef.current = { ...pendingPersistRef.current, ...overrides };'),
     'page should merge back-to-back settings changes before sending them',
@@ -1126,26 +1135,31 @@ test('font settings let users pick and save alternate terminal fonts', () => {
   const pageSource = readFileSync(join(import.meta.dirname, '../app/page.tsx'), 'utf8');
   const cssSource = readFileSync(join(import.meta.dirname, '../app/globals.css'), 'utf8');
   const fontsSource = readFileSync(join(import.meta.dirname, '../lib/fonts.ts'), 'utf8');
-  const migrateSource = readFileSync(join(import.meta.dirname, '../scripts/migrate.mjs'), 'utf8');
+  const layoutSource = readFileSync(join(import.meta.dirname, '../app/layout.tsx'), 'utf8');
   assert.ok(
     fontsSource.includes("label: 'Courier New'") &&
       fontsSource.includes("label: 'Menlo'") &&
       fontsSource.includes("label: 'Consolas'") &&
-      fontsSource.includes("label: 'Monaco'"),
-    'the app should expose a small built-in list of terminal-style font options',
+      fontsSource.includes("label: 'Monaco'") &&
+      fontsSource.includes("label: 'JetBrains Mono'") &&
+      fontsSource.includes("label: 'IBM Plex Mono'"),
+    'the app should expose a curated built-in list of terminal-style font options',
   );
   assert.ok(
     pageSource.includes("const FONT_KEY     = 'gippidy-font';") &&
+      pageSource.includes("const CUSTOM_FONT_FAMILY_KEY = 'gippidy-custom-font-family';") &&
       pageSource.includes("const [font, setFont]                         = useState<FontId>(DEFAULT_FONT_ID);") &&
+      pageSource.includes("const [customFontFamily, setCustomFontFamily] = useState('');") &&
       pageSource.includes("const savedFont = localStorage.getItem(FONT_KEY);") &&
-      pageSource.includes("if (savedFont && isFontId(savedFont)) applyFont(savedFont);"),
-    'page should restore the saved font choice from localStorage during startup',
+      pageSource.includes("const savedCustomFontFamily = normalizeCustomFontFamily(localStorage.getItem(CUSTOM_FONT_FAMILY_KEY));"),
+    'page should restore the saved font choice and custom stack from localStorage during startup',
   );
   assert.ok(
     pageSource.includes("logClientEvent('settings.invalid_font', 'warn'") &&
-      pageSource.includes("persistSettings({ font: nextFont }, true);") &&
+      pageSource.includes('Custom font stack') &&
+      pageSource.includes('handleCustomFontFamilyChange') &&
       pageSource.includes('<label>Font</label>'),
-    'settings should let the user choose a font and persist it immediately',
+    'settings should let the user choose a font and optionally enter a custom local font stack',
   );
   assert.ok(
     cssSource.includes('--app-font-family:') &&
@@ -1153,9 +1167,10 @@ test('font settings let users pick and save alternate terminal fonts', () => {
     'globals.css should route app text through a CSS variable so the selected font applies everywhere',
   );
   assert.ok(
-    migrateSource.includes("font_family   TEXT NOT NULL DEFAULT 'courier-new'") &&
-      migrateSource.includes("ALTER TABLE user_settings ADD COLUMN IF NOT EXISTS font_family TEXT NOT NULL DEFAULT 'courier-new'"),
-    'database migrations should persist the selected font in user_settings',
+    layoutSource.includes("JetBrains_Mono") &&
+      layoutSource.includes("IBM_Plex_Mono") &&
+      layoutSource.includes("const FONT_BOOTSTRAP ="),
+    'layout should load the bundled web fonts and bootstrap the saved font before hydration',
   );
 });