diff --git a/e2e/support/mock-supabase.ts b/e2e/support/mock-supabase.ts
index f9ec8f0..c41451c 100644
--- a/e2e/support/mock-supabase.ts
+++ b/e2e/support/mock-supabase.ts
@@ -653,6 +653,16 @@ async function handleFeedbackRpc(
   sendJson(res, 200, [{ ...row }]);
 }
 
+function handleDmojProblem(res: http.ServerResponse, problemCode: string): void {
+  if (provider === 'fail') {
+    sendJson(res, 503, { error: 'mock dmoj upstream failure' });
+    return;
+  }
+  sendJson(res, 200, {
+    data: { object: { code: problemCode, name: 'Mock DMOJ Problem', types: ['Simulation'] } }
+  });
+}
+
 function handleKattisPage(res: http.ServerResponse): void {
   if (provider === 'fail') {
     res.writeHead(500, { 'Content-Type': 'text/plain' });
@@ -786,6 +796,12 @@ const server = http.createServer(async (req, res) => {
     handleCodeforcesUserStatus(res);
     return;
   }
+  if (url.pathname.startsWith('/api/dmoj/problem/')) {
+    // DMOJ problem API (dmoj.ca/api/v2/problem/<code>) redirected here.
+    await readBody(req);
+    handleDmojProblem(res, url.pathname.slice('/api/dmoj/problem/'.length));
+    return;
+  }
 
   // Current-actor interaction reads and isolated writes.
   if (url.pathname === '/rest/v1/user_preferences') {
diff --git a/playwright.config.ts b/playwright.config.ts
index b4d1e01..7e19fc7 100644
--- a/playwright.config.ts
+++ b/playwright.config.ts
@@ -67,10 +67,11 @@ const mockPreviewWebServer = {
     // deterministic Supabase storage key the auth-seeding init script targets.
     PUBLIC_SUPABASE_URL: MOCK_SUPABASE_URL,
     PUBLIC_SUPABASE_PUBLISHABLE_KEY: 'mock-publishable-key',
-    // Redirect the server-side provider fetches (problemset / Kattis page) to
-    // the mock so no live provider is ever contacted during E2E.
+    // Redirect the server-side provider fetches (problemset / Kattis page /
+    // DMOJ API) to the mock so no live provider is ever contacted during E2E.
     PUBLIC_CODEFORCES_API_BASE: `${MOCK_SUPABASE_URL}/api`,
-    PUBLIC_KATTIS_BASE: MOCK_SUPABASE_URL
+    PUBLIC_KATTIS_BASE: MOCK_SUPABASE_URL,
+    PUBLIC_DMOJ_API_BASE: `${MOCK_SUPABASE_URL}/api/dmoj`
   }
 };
 
diff --git a/scripts/coverage-hooks.mjs b/scripts/coverage-hooks.mjs
index 1072866..60ef790 100644
--- a/scripts/coverage-hooks.mjs
+++ b/scripts/coverage-hooks.mjs
@@ -9,7 +9,8 @@ const publicEnv = Object.freeze({
   PUBLIC_SUPABASE_URL: process.env.PUBLIC_SUPABASE_URL ?? 'http://localhost',
   PUBLIC_SUPABASE_PUBLISHABLE_KEY: process.env.PUBLIC_SUPABASE_PUBLISHABLE_KEY ?? 'placeholder',
   PUBLIC_CODEFORCES_API_BASE: process.env.PUBLIC_CODEFORCES_API_BASE,
-  PUBLIC_KATTIS_BASE: process.env.PUBLIC_KATTIS_BASE
+  PUBLIC_KATTIS_BASE: process.env.PUBLIC_KATTIS_BASE,
+  PUBLIC_DMOJ_API_BASE: process.env.PUBLIC_DMOJ_API_BASE
 });
 const virtualModules = new Map([
   ['$app/environment', 'export const browser = false; export const dev = false;'],
diff --git a/src/lib/collections/problemCollection.ts b/src/lib/collections/problemCollection.ts
index 5763ec3..27bb07a 100644
--- a/src/lib/collections/problemCollection.ts
+++ b/src/lib/collections/problemCollection.ts
@@ -25,7 +25,7 @@ export type SolvedFilter = 'all' | 'solved' | 'unsolved';
 export type ProblemSourceFilter = 'all' | Problem['source'];
 
 const SOLVED_FILTER_STATES = ['all', 'solved', 'unsolved'] as const;
-const SOURCE_FILTER_STATES = ['all', 'codeforces', 'kattis'] as const;
+const SOURCE_FILTER_STATES = ['all', 'codeforces', 'kattis', 'dmoj'] as const;
 
 type ProblemCollectionState = {
   sourceItems: readonly Problem[];
diff --git a/src/lib/components/ProblemTable.svelte b/src/lib/components/ProblemTable.svelte
index 3955ced..dd6e69e 100644
--- a/src/lib/components/ProblemTable.svelte
+++ b/src/lib/components/ProblemTable.svelte
@@ -10,6 +10,12 @@
   import TableFeedbackButtons from './TableFeedbackButtons.svelte';
   const codeforcesLogo = '/images/codeforces.png';
   const kattisLogo = '/images/kattis.png';
+  const dmojLogo = '/images/dmoj.svg';
+  const SOURCE_LOGOS: Record<Problem['source'], string> = {
+    codeforces: codeforcesLogo,
+    kattis: kattisLogo,
+    dmoj: dmojLogo
+  };
 
   export let problems: Problem[] = [];
   export let bodyId: string | undefined = undefined;
@@ -22,7 +28,7 @@
   export let difficultySortDirection: SortDirection = null;
   export let solvedFilterState: 'all' | 'solved' | 'unsolved' = 'all';
   export let authorFilterValue: string | null = null;
-  export let sourceFilterValue: 'all' | 'codeforces' | 'kattis' = 'all';
+  export let sourceFilterValue: 'all' | Problem['source'] = 'all';
   export let onLike: (problemId: string, isLike: boolean) => Promise<void>;
   export let onToggleSolved: (problemId: string, isSolved: boolean) => Promise<void>;
   export let onDifficultySort: () => void;
@@ -74,6 +80,8 @@
   function getDifficultyTooltip(problem: Problem): string {
     if (problem.source === 'kattis') {
       return `Kattis difficulty mapped from 1-10 scale to 800-3500 rating range`;
+    } else if (problem.source === 'dmoj') {
+      return `DMOJ scores problems in points, which are not comparable to the 800-3500 rating range`;
     } else {
       return `${getRatingTierName(problem.difficulty)}`;
     }
@@ -180,6 +188,15 @@
                   ></div>
                 </div>
               </span>
+            {:else if sourceFilterValue === 'dmoj'}
+              <span class="text-sm font-bold text-[#2e7d32]" aria-hidden="true">
+                <div class="relative">
+                  <img src={dmojLogo} alt="" class="h-5 w-5 object-contain" />
+                  <div
+                    class="absolute -right-1 -bottom-1 h-3 w-3 rounded border border-white bg-[#2e7d32]"
+                  ></div>
+                </div>
+              </span>
             {:else}
               <span class="text-sm font-bold text-[var(--color-text-muted)]" aria-hidden="true">
                 <svg
@@ -298,7 +315,7 @@
           <td class="p-2 text-center md:p-3">
             <span class="flex items-center justify-center">
               <img
-                src={problem.source === 'codeforces' ? codeforcesLogo : kattisLogo}
+                src={SOURCE_LOGOS[problem.source]}
                 alt={problem.source}
                 class="h-6 w-6 object-contain"
               />
diff --git a/src/lib/providers/dmoj/ingestion.ts b/src/lib/providers/dmoj/ingestion.ts
new file mode 100644
index 0000000..f96c196
--- /dev/null
+++ b/src/lib/providers/dmoj/ingestion.ts
@@ -0,0 +1,150 @@
+import type {
+  DuplicateCheckResult,
+  ExtractedEntry,
+  ProblemDraft,
+  ResolvedItem
+} from '../../submit/types.ts';
+
+export const DMOJ_HOST = 'dmoj.ca';
+const ALLOWED_HOSTS = new Set([DMOJ_HOST, 'www.dmoj.ca']);
+
+export type DmojProblemInfo = { problemCode: string; url: string };
+export type DmojProblemMetadata = { name: string; types: string[] };
+
+export type DmojIngestionDependencies = {
+  checkProblem: (canonicalUrl: string) => Promise<DuplicateCheckResult>;
+  fetchProblem: (url: string) => Promise<unknown>;
+  parseProblem?: (payload: unknown, problemCode: string) => DmojProblemMetadata;
+  now?: () => string;
+  logError?: (message: string, error: unknown) => void;
+};
+
+export function buildCanonicalDmojProblemUrl(problemCode: string): string {
+  return `https://${DMOJ_HOST}/problem/${problemCode}`;
+}
+
+/**
+ * Reduce input to a DMOJ problem code. Unlike Kattis this rejects bare codes:
+ * DMOJ codes are opaque short strings, so accepting them unqualified would let
+ * any stray word classify as a DMOJ problem.
+ */
+export function parseDmojProblemCode(input: string): string | null {
+  if (typeof input !== 'string') return null;
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+
+  const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(trimmed);
+  const isSchemeRelative = trimmed.startsWith('//');
+  const candidate = hasScheme || isSchemeRelative ? trimmed : `https://${trimmed}`;
+
+  let parsed: URL;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== 'https:' || !ALLOWED_HOSTS.has(parsed.hostname)) return null;
+  if (parsed.username || parsed.password || parsed.port) return null;
+  return parsed.pathname.match(/^\/problem\/([a-z0-9_]+)$/)?.[1] ?? null;
+}
+
+export function parseDmojProblem(input: string): DmojProblemInfo | null {
+  const problemCode = parseDmojProblemCode(input);
+  return problemCode ? { problemCode, url: buildCanonicalDmojProblemUrl(problemCode) } : null;
+}
+
+export function extractDmojEntries(text: string): ExtractedEntry[] {
+  const seen = new Set<string>();
+  const entries: ExtractedEntry[] = [];
+  for (const input of text.split(/[\n\s]+/)) {
+    const info = parseDmojProblem(input.trim());
+    if (!info || seen.has(info.url)) continue;
+    seen.add(info.url);
+    entries.push({ kind: 'problem', url: info.url });
+  }
+  return entries;
+}
+
+export function formatDmojLabel(url: string, name?: string): string {
+  if (name) return name;
+  return url.replace(/^https?:\/\/(?:www\.)?dmoj\.ca\/problem\/([a-z0-9_]+).*$/, '$1');
+}
+
+/** Read the name and problem types out of a DMOJ API v2 single-problem payload. */
+export function parseDmojProblemPayload(
+  payload: unknown,
+  problemCode: string
+): DmojProblemMetadata {
+  const object = (payload as { data?: { object?: Record<string, unknown> } })?.data?.object;
+  const name = typeof object?.name === 'string' ? object.name.trim() : '';
+  const types = Array.isArray(object?.types)
+    ? object.types.filter((type): type is string => typeof type === 'string')
+    : [];
+  return { name: name || problemCode, types };
+}
+
+export function createDmojIngestion(dependencies: DmojIngestionDependencies) {
+  const now = dependencies.now ?? (() => new Date().toISOString());
+  const parseProblem = dependencies.parseProblem ?? parseDmojProblemPayload;
+  const logError =
+    dependencies.logError ?? ((message: string, error: unknown) => console.error(message, error));
+
+  async function resolve(
+    entry: ExtractedEntry,
+    handle: string = 'anonymous'
+  ): Promise<ResolvedItem> {
+    const info = parseDmojProblem(entry.url);
+    if (!info) {
+      return {
+        valid: false,
+        kind: 'problem',
+        label: entry.url,
+        url: entry.url,
+        reason: 'Invalid URL'
+      };
+    }
+
+    const duplicate = await dependencies.checkProblem(info.url);
+    if (duplicate.error || duplicate.duplicate) {
+      return {
+        valid: false,
+        kind: 'problem',
+        label: formatDmojLabel(info.url),
+        url: info.url,
+        reason: duplicate.message ?? duplicate.error ?? 'Problem already exists in database'
+      };
+    }
+
+    // DMOJ scores problems in points, which are not comparable to the stored
+    // Codeforces-style rating range, so difficulty is deliberately left unset.
+    let metadata: DmojProblemMetadata;
+    try {
+      metadata = parseProblem(await dependencies.fetchProblem(info.url), info.problemCode);
+    } catch (error) {
+      logError('Error fetching DMOJ problem metadata:', error);
+      metadata = { name: info.problemCode, types: [] };
+    }
+
+    const draft: ProblemDraft = {
+      name: metadata.name,
+      tags: metadata.types,
+      url: info.url,
+      solved: 0,
+      dateAdded: now(),
+      addedBy: handle,
+      addedByUrl: handle ? `https://${DMOJ_HOST}/user/${handle}` : `https://${DMOJ_HOST}`,
+      likes: 0,
+      dislikes: 0
+    };
+
+    return {
+      valid: true,
+      kind: 'problem',
+      label: formatDmojLabel(info.url, draft.name),
+      url: info.url,
+      payload: draft
+    };
+  }
+
+  return { extract: extractDmojEntries, resolve };
+}
diff --git a/src/lib/queries/problemQueries.ts b/src/lib/queries/problemQueries.ts
index 5ea050a..64fd982 100644
--- a/src/lib/queries/problemQueries.ts
+++ b/src/lib/queries/problemQueries.ts
@@ -13,7 +13,7 @@ export type Problem = {
   addedByUrl: string;
   likes: number;
   dislikes: number;
-  source: 'codeforces' | 'kattis';
+  source: 'codeforces' | 'kattis' | 'dmoj';
   type?: string;
 };
 
diff --git a/src/lib/services/problemSource.ts b/src/lib/services/problemSource.ts
index 0ef3553..262c4b0 100644
--- a/src/lib/services/problemSource.ts
+++ b/src/lib/services/problemSource.ts
@@ -1,6 +1,8 @@
+import { parseDmojProblemCode } from '../providers/dmoj/ingestion.ts';
 import { parseKattisProblemId } from '../providers/kattis/ingestion.ts';
 
-/** Determine the problem source using the exact-host Kattis URL validator. */
-export function getProblemSource(url: string): 'codeforces' | 'kattis' {
+/** Determine the problem source using the exact-host provider URL validators. */
+export function getProblemSource(url: string): 'codeforces' | 'kattis' | 'dmoj' {
+  if (parseDmojProblemCode(url)) return 'dmoj';
   return parseKattisProblemId(url) ? 'kattis' : 'codeforces';
 }
diff --git a/src/lib/submit/providers/dmoj.ts b/src/lib/submit/providers/dmoj.ts
new file mode 100644
index 0000000..7d92466
--- /dev/null
+++ b/src/lib/submit/providers/dmoj.ts
@@ -0,0 +1,33 @@
+import { createDmojIngestion } from '$lib/providers/dmoj/ingestion';
+import type { ProviderAdapter, SubmissionPersistence } from '$lib/submit/types';
+
+async function fetchDmojProblem(url: string, fetchProblem: typeof fetch = fetch): Promise<unknown> {
+  const response = await fetchProblem(`/api/dmoj?url=${encodeURIComponent(url)}`);
+  const data = (await response.json()) as { problem?: unknown; error?: string };
+  if (!response.ok) throw new Error(data.error || 'Failed to fetch problem');
+  return data.problem;
+}
+
+export function createDmojSubmitAdapter(
+  persistence: SubmissionPersistence,
+  fetchProblem: typeof fetch = fetch
+): ProviderAdapter {
+  const ingestion = createDmojIngestion({
+    checkProblem: async (url) => persistence.checkEquivalentProblemUrls(url),
+    fetchProblem: (url) => fetchDmojProblem(url, fetchProblem)
+  });
+
+  return {
+    id: 'dmoj',
+    name: 'DMOJ',
+    icon: '/images/dmoj.svg',
+    placeholder: 'https://dmoj.ca/problem/ciw26p2\nhttps://dmoj.ca/problem/helloworld',
+    help: 'Paste DMOJ problem URLs. Separate entries with spaces or new lines.',
+    extract: ingestion.extract,
+    resolve: ingestion.resolve,
+    commit: (item) =>
+      item.kind === 'problem'
+        ? persistence.insertProblem(item.payload)
+        : Promise.resolve({ success: false, message: 'Failed to add entry' })
+  };
+}
diff --git a/src/lib/submit/providers/index.ts b/src/lib/submit/providers/index.ts
index 37b9e4f..8b47d7c 100644
--- a/src/lib/submit/providers/index.ts
+++ b/src/lib/submit/providers/index.ts
@@ -5,14 +5,16 @@ import {
 } from '$lib/submit/submissionPersistence';
 import type { ProviderAdapters } from '$lib/submit/types';
 import { createCodeforcesSubmitAdapter } from './codeforces';
+import { createDmojSubmitAdapter } from './dmoj';
 import { createKattisSubmitAdapter } from './kattis';
 
 export function createProviderAdapters(): ProviderAdapters {
   const persistence = createSubmissionPersistence(supabase as unknown as SubmissionClient);
   return {
     codeforces: createCodeforcesSubmitAdapter(persistence),
-    kattis: createKattisSubmitAdapter(persistence)
+    kattis: createKattisSubmitAdapter(persistence),
+    dmoj: createDmojSubmitAdapter(persistence)
   };
 }
 
-export const providerOrder = ['codeforces', 'kattis'] as const;
+export const providerOrder = ['codeforces', 'kattis', 'dmoj'] as const;
diff --git a/src/lib/submit/types.ts b/src/lib/submit/types.ts
index 6706d44..9830155 100644
--- a/src/lib/submit/types.ts
+++ b/src/lib/submit/types.ts
@@ -1,4 +1,4 @@
-export type ProviderId = 'codeforces' | 'kattis';
+export type ProviderId = 'codeforces' | 'kattis' | 'dmoj';
 export type SubmitItemKind = 'problem' | 'contest';
 export type WorkflowStage = 'source' | 'links' | 'review' | 'complete';
 
diff --git a/src/lib/submit/workflow.ts b/src/lib/submit/workflow.ts
index 5585570..d5d44e0 100644
--- a/src/lib/submit/workflow.ts
+++ b/src/lib/submit/workflow.ts
@@ -22,7 +22,9 @@ export type ResolveOutcome =
 
 export function providerFromUrl(url: URL): ProviderId | undefined {
   const provider = url.searchParams.get('provider');
-  return provider === 'codeforces' || provider === 'kattis' ? provider : undefined;
+  return provider === 'codeforces' || provider === 'kattis' || provider === 'dmoj'
+    ? provider
+    : undefined;
 }
 
 function deriveState(
diff --git a/src/routes/api/dmoj/+server.ts b/src/routes/api/dmoj/+server.ts
new file mode 100644
index 0000000..158eeec
--- /dev/null
+++ b/src/routes/api/dmoj/+server.ts
@@ -0,0 +1,64 @@
+import { env as publicEnv } from '$env/dynamic/public';
+import { json } from '@sveltejs/kit';
+import { DMOJ_HOST, parseDmojProblemCode } from '$lib/providers/dmoj/ingestion';
+import type { RequestHandler } from './$types';
+
+const FETCH_TIMEOUT_MS = 10_000;
+
+export function _buildUpstreamUrl(
+  problemCode: string,
+  base: string | undefined = publicEnv.PUBLIC_DMOJ_API_BASE
+): string {
+  if (!base) {
+    return `https://${DMOJ_HOST}/api/v2/problem/${problemCode}`;
+  }
+  return `${base.replace(/\/$/, '')}/problem/${problemCode}`;
+}
+
+/**
+ * Returns DMOJ problem metadata without exposing an arbitrary-URL proxy.
+ *
+ * The caller input is reduced to a validated problem code before either the
+ * canonical DMOJ API origin or the optional test upstream is constructed. The
+ * public problem pages sit behind bot protection, so the API is the only
+ * reliable metadata source.
+ */
+export function _createDmojGet(fetchProblem: typeof fetch): RequestHandler {
+  return async ({ url }) => {
+    const problemParam = url.searchParams.get('url');
+    if (!problemParam) {
+      return json({ error: 'No URL provided' }, { status: 400 });
+    }
+
+    const problemCode = parseDmojProblemCode(problemParam);
+    if (!problemCode) {
+      return json({ error: 'Invalid DMOJ problem URL' }, { status: 400 });
+    }
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+    const request = (async () => {
+      try {
+        const response = await fetchProblem(_buildUpstreamUrl(problemCode), {
+          signal: controller.signal,
+          redirect: 'error'
+        });
+        if (!response.ok) {
+          return json({ error: 'Failed to fetch problem' }, { status: response.status });
+        }
+        return json({ problem: await response.json() });
+      } catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+          return json({ error: 'Timed out fetching problem' }, { status: 504 });
+        }
+        console.error('Error fetching DMOJ problem:', error);
+        return json({ error: 'Failed to fetch problem' }, { status: 500 });
+      }
+    })();
+
+    return request.finally(() => clearTimeout(timeout));
+  };
+}
+
+export const GET = _createDmojGet(fetch);
diff --git a/static/images/dmoj.svg b/static/images/dmoj.svg
new file mode 100644
index 0000000..e8c1d12
--- /dev/null
+++ b/static/images/dmoj.svg
@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32" role="img">
+  <rect width="32" height="32" rx="6" fill="#2e7d32" />
+  <path
+    fill="#ffffff"
+    fill-rule="evenodd"
+    d="M9 7h7a9 9 0 0 1 0 18H9V7Zm4 4v10h3a5 5 0 0 0 0-10h-3Z"
+  />
+</svg>
diff --git a/tests/api-routes.test.ts b/tests/api-routes.test.ts
index ae5f4ba..cec4b6d 100644
--- a/tests/api-routes.test.ts
+++ b/tests/api-routes.test.ts
@@ -8,6 +8,10 @@ import {
   GET as UserSolvesGET
 } from '../src/routes/api/codeforces/user-solves/+server.ts';
 import { _buildUpstreamUrl, _createKattisGet } from '../src/routes/api/kattis/+server.ts';
+import {
+  _buildUpstreamUrl as _buildDmojUpstreamUrl,
+  _createDmojGet
+} from '../src/routes/api/dmoj/+server.ts';
 import { createSessionBoundSupabase, supabase } from '../src/lib/services/database.ts';
 
 const authorized = async () => ({
@@ -419,6 +423,121 @@ test('the production upstream builder honors an override base and the canonical
   assert.equal(_buildUpstreamUrl('hello'), 'https://open.kattis.com/problems/hello');
 });
 
+test('DMOJ route rejects absent and unsafe targets before fetching', async () => {
+  let fetched = 0;
+  const handler = _createDmojGet(async () => {
+    fetched++;
+    throw new Error('must not fetch');
+  });
+  for (const [url, error] of [
+    ['https://gitgud.test/api', 'No URL provided'],
+    ['https://gitgud.test/api?url=https://evil.test/problem/ciw26p2', 'Invalid DMOJ problem URL'],
+    // A bare code is not a DMOJ URL, so it never reaches the upstream.
+    ['https://gitgud.test/api?url=ciw26p2', 'Invalid DMOJ problem URL']
+  ]) {
+    const response = await handler({ url: new URL(url) } as never);
+    assert.equal(response.status, 400);
+    assert.deepEqual(await body(response), { error });
+  }
+  assert.equal(fetched, 0);
+});
+
+test('DMOJ route rebuilds canonical target and returns JSON or upstream status', async () => {
+  let requested = '';
+  let options: RequestInit | undefined;
+  const success = _createDmojGet(async (input, init) => {
+    requested = String(input);
+    options = init;
+    return Response.json({ data: { object: { name: 'Number Shuffle' } } });
+  });
+  const response = await success({
+    url: new URL('https://gitgud.test/api?url=https://www.dmoj.ca/problem/ciw26p2')
+  } as never);
+  assert.deepEqual(await body(response), {
+    problem: { data: { object: { name: 'Number Shuffle' } } }
+  });
+  assert.equal(requested, 'https://dmoj.ca/api/v2/problem/ciw26p2');
+  assert.equal(options?.redirect, 'error');
+
+  const failed = _createDmojGet(async () => new Response('', { status: 404 }));
+  const failure = await failed({
+    url: new URL('https://gitgud.test/api?url=https://dmoj.ca/problem/ciw26p2')
+  } as never);
+  assert.equal(failure.status, 404);
+  assert.deepEqual(await body(failure), { error: 'Failed to fetch problem' });
+});
+
+test('DMOJ route distinguishes aborts from other fetch failures', async () => {
+  const abort = new Error('aborted');
+  abort.name = 'AbortError';
+  for (const [failure, status, error] of [
+    [abort, 504, 'Timed out fetching problem'],
+    [new Error('offline'), 500, 'Failed to fetch problem'],
+    ['non-Error failure', 500, 'Failed to fetch problem']
+  ] as const) {
+    const handler = _createDmojGet(async () => {
+      throw failure;
+    });
+    const response = await handler({
+      url: new URL('https://gitgud.test/api?url=https://dmoj.ca/problem/ciw26p2')
+    } as never);
+    assert.equal(response.status, status);
+    assert.deepEqual(await body(response), { error });
+  }
+});
+
+test('DMOJ route contains response body failures', async () => {
+  const handler = _createDmojGet(async () => {
+    return {
+      ok: true,
+      json: async () => {
+        throw new Error('body disconnected');
+      }
+    } as unknown as Response;
+  });
+  const response = await handler({
+    url: new URL('https://gitgud.test/api?url=https://dmoj.ca/problem/ciw26p2')
+  } as never);
+  assert.equal(response.status, 500);
+  assert.deepEqual(await body(response), { error: 'Failed to fetch problem' });
+});
+
+test('DMOJ route aborts the upstream fetch once the timeout elapses', async (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] });
+  const handler = _createDmojGet(
+    (_input, init) =>
+      new Promise((_resolve, reject) => {
+        (init as RequestInit).signal?.addEventListener('abort', () => {
+          const abort = new Error('aborted');
+          abort.name = 'AbortError';
+          reject(abort);
+        });
+      })
+  );
+  const pending = handler({
+    url: new URL('https://gitgud.test/api?url=https://dmoj.ca/problem/ciw26p2')
+  } as never);
+  await Promise.resolve();
+  t.mock.timers.tick(10_000);
+  const response = await pending;
+  assert.equal(response.status, 504);
+  assert.deepEqual(await body(response), { error: 'Timed out fetching problem' });
+});
+
+test('the production DMOJ upstream builder honors an override base and the canonical origin', () => {
+  assert.equal(
+    _buildDmojUpstreamUrl('ciw26p2', 'https://mirror.test/'),
+    'https://mirror.test/problem/ciw26p2'
+  );
+  assert.equal(
+    _buildDmojUpstreamUrl('ciw26p2', 'https://mirror.test'),
+    'https://mirror.test/problem/ciw26p2'
+  );
+  assert.equal(_buildDmojUpstreamUrl('ciw26p2', ''), 'https://dmoj.ca/api/v2/problem/ciw26p2');
+  // No override argument falls through to the configured environment base.
+  assert.equal(_buildDmojUpstreamUrl('ciw26p2'), 'https://dmoj.ca/api/v2/problem/ciw26p2');
+});
+
 test('the production catalog loader fetches and caches the problemset once', async () => {
   let fetches = 0;
   const fetchFn = (async () => {
diff --git a/tests/dmoj-ingestion.test.ts b/tests/dmoj-ingestion.test.ts
new file mode 100644
index 0000000..aad21f3
--- /dev/null
+++ b/tests/dmoj-ingestion.test.ts
@@ -0,0 +1,172 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  createDmojIngestion,
+  extractDmojEntries,
+  formatDmojLabel,
+  parseDmojProblem,
+  parseDmojProblemCode,
+  parseDmojProblemPayload,
+  type DmojIngestionDependencies
+} from '../src/lib/providers/dmoj/ingestion.ts';
+
+const now = '2026-01-01T00:00:00.000Z';
+
+function ingestion(overrides: Partial<DmojIngestionDependencies> = {}) {
+  return createDmojIngestion({
+    checkProblem: async () => ({ duplicate: false }),
+    fetchProblem: async () => ({}),
+    parseProblem: () => ({ name: 'Number Shuffle', types: ['Simulation'] }),
+    now: () => now,
+    logError: () => {},
+    ...overrides
+  });
+}
+
+test('accepts only fully qualified DMOJ problem URLs and deduplicates', () => {
+  assert.deepEqual(
+    extractDmojEntries(
+      'https://dmoj.ca/problem/ciw26p2 https://www.dmoj.ca/problem/ciw26p2\ndmoj.ca/problem/helloworld'
+    ),
+    [
+      { kind: 'problem', url: 'https://dmoj.ca/problem/ciw26p2' },
+      { kind: 'problem', url: 'https://dmoj.ca/problem/helloworld' }
+    ]
+  );
+  // A bare code is never a DMOJ problem: the codes are opaque short strings.
+  assert.deepEqual(extractDmojEntries('ciw26p2'), []);
+});
+
+test('problem code parsing rejects every untrusted or malformed target', () => {
+  for (const input of [
+    '',
+    '   ',
+    'http://',
+    'http://dmoj.ca/problem/ciw26p2',
+    'https://dmoj.ca.evil.example/problem/ciw26p2',
+    'https://dmoj.ca:8443/problem/ciw26p2',
+    'https://user:pass@dmoj.ca/problem/ciw26p2',
+    'https://dmoj.ca/problem/ciw26p2/submit',
+    'https://dmoj.ca/user/ciw26p2',
+    'https://dmoj.ca/problem/CIW26P2',
+    // Scheme-relative input carries no base to resolve against.
+    '//dmoj.ca/problem/ciw26p2'
+  ]) {
+    assert.equal(parseDmojProblemCode(input), null, input);
+  }
+  assert.equal(parseDmojProblemCode(null as unknown as string), null);
+  assert.equal(parseDmojProblemCode(' https://dmoj.ca/problem/an_underscore '), 'an_underscore');
+});
+
+test('problem parsing and labels preserve canonical codes', () => {
+  assert.deepEqual(parseDmojProblem('https://www.dmoj.ca/problem/ciw26p2'), {
+    problemCode: 'ciw26p2',
+    url: 'https://dmoj.ca/problem/ciw26p2'
+  });
+  assert.equal(parseDmojProblem('not valid'), null);
+  assert.equal(formatDmojLabel('https://dmoj.ca/problem/ciw26p2'), 'ciw26p2');
+  assert.equal(
+    formatDmojLabel('https://dmoj.ca/problem/ciw26p2', 'Number Shuffle'),
+    'Number Shuffle'
+  );
+});
+
+test('API payload parsing tolerates every missing or mistyped field', () => {
+  assert.deepEqual(
+    parseDmojProblemPayload(
+      { data: { object: { name: '  Number Shuffle  ', types: ['Simulation', 7] } } },
+      'ciw26p2'
+    ),
+    { name: 'Number Shuffle', types: ['Simulation'] }
+  );
+  assert.deepEqual(parseDmojProblemPayload({ data: { object: { name: '   ' } } }, 'ciw26p2'), {
+    name: 'ciw26p2',
+    types: []
+  });
+  assert.deepEqual(parseDmojProblemPayload({ data: { object: { name: 7, types: 'x' } } }, 'x1'), {
+    name: 'x1',
+    types: []
+  });
+  assert.deepEqual(parseDmojProblemPayload(undefined, 'x1'), { name: 'x1', types: [] });
+});
+
+test('API metadata produces exact defaults, submitter profile, and label', async () => {
+  const service = ingestion();
+  const [entry] = service.extract('https://dmoj.ca/problem/ciw26p2');
+  assert.deepEqual(await service.resolve(entry, 'alice'), {
+    valid: true,
+    kind: 'problem',
+    label: 'Number Shuffle',
+    url: entry.url,
+    payload: {
+      name: 'Number Shuffle',
+      tags: ['Simulation'],
+      url: entry.url,
+      solved: 0,
+      dateAdded: now,
+      addedBy: 'alice',
+      addedByUrl: 'https://dmoj.ca/user/alice',
+      likes: 0,
+      dislikes: 0
+    }
+  });
+});
+
+test('fetch or parse failure logs and remains a valid code-named fallback row', async () => {
+  const logs: unknown[][] = [];
+  const service = ingestion({
+    fetchProblem: async () => {
+      throw new Error('offline');
+    },
+    logError: (...values: unknown[]) => logs.push(values)
+  });
+  const [entry] = service.extract('https://dmoj.ca/problem/ciw26p2');
+  const row = await service.resolve(entry, '');
+  assert.equal(row.valid, true);
+  assert.equal(row.valid && row.label, 'ciw26p2');
+  assert.equal(row.valid && row.payload.difficulty, undefined);
+  assert.deepEqual(row.valid && row.kind === 'problem' ? row.payload.tags : null, []);
+  assert.equal(row.valid && row.payload.addedByUrl, 'https://dmoj.ca');
+  assert.equal(logs[0][0], 'Error fetching DMOJ problem metadata:');
+});
+
+test('invalid entries and duplicate errors avoid API fetches', async () => {
+  let fetches = 0;
+  const service = ingestion({
+    checkProblem: async () => ({ duplicate: false, error: 'database unavailable' }),
+    fetchProblem: async () => {
+      fetches++;
+      return {};
+    }
+  });
+  const invalid = await service.resolve(
+    { kind: 'problem', url: 'https://evil.test/problem/x' },
+    ''
+  );
+  assert.deepEqual(invalid, {
+    valid: false,
+    kind: 'problem',
+    label: 'https://evil.test/problem/x',
+    url: 'https://evil.test/problem/x',
+    reason: 'Invalid URL'
+  });
+  const [entry] = service.extract('https://dmoj.ca/problem/ciw26p2');
+  const duplicate = await service.resolve(entry, '');
+  assert.equal(duplicate.valid, false);
+  assert.equal(duplicate.valid ? '' : duplicate.reason, 'database unavailable');
+  assert.equal(fetches, 0);
+});
+
+test('duplicate checks are read-only and ingestion exposes no persistence write', async () => {
+  let checks = 0;
+  const service = ingestion({
+    checkProblem: async () => (checks++, { duplicate: true })
+  });
+  const [entry] = service.extract('https://dmoj.ca/problem/ciw26p2');
+  const row = await service.resolve(entry, '');
+  assert.equal(checks, 1);
+  assert.equal(row.valid, false);
+  assert.equal(row.valid ? '' : row.reason, 'Problem already exists in database');
+  assert.equal(row.valid ? '' : row.label, 'ciw26p2');
+  assert.equal('commit' in service, false);
+});
diff --git a/tests/problem-collection.test.ts b/tests/problem-collection.test.ts
index 3149fc5..da0bef5 100644
--- a/tests/problem-collection.test.ts
+++ b/tests/problem-collection.test.ts
@@ -58,7 +58,7 @@ test('problem collection applies every current filter together', () => {
   const solvedProblemIds = new Set(['a', 'c']);
   const topics = [null, 'graph', 'misc', NEW_PROBLEM_TOPIC] as const;
   const solvedFilters = ['all', 'solved', 'unsolved'] as const;
-  const sourceFilters = ['all', 'codeforces', 'kattis'] as const;
+  const sourceFilters = ['all', 'codeforces', 'kattis', 'dmoj'] as const;
   const authors = [null, 'alice', 'bob'] as const;
 
   for (const selectedTopic of topics) {
@@ -140,6 +140,9 @@ test('problem solved and source filters cycle in the existing order', () => {
   collection = collection.cycleSourceFilter();
   assert.deepEqual(ids(collection), ['c', 'd']);
   collection = collection.cycleSourceFilter();
+  assert.equal(collection.sourceFilter, 'dmoj');
+  assert.deepEqual(ids(collection), []);
+  collection = collection.cycleSourceFilter();
   assert.equal(collection.sourceFilter, 'all');
 });
 
diff --git a/tests/problem-source.test.ts b/tests/problem-source.test.ts
index 7a11bf3..352facf 100644
--- a/tests/problem-source.test.ts
+++ b/tests/problem-source.test.ts
@@ -7,6 +7,11 @@ test('classifies canonical Kattis problem URLs', () => {
   assert.equal(getProblemSource('https://kattis.com/problems/hello'), 'kattis');
 });
 
+test('classifies canonical DMOJ problem URLs', () => {
+  assert.equal(getProblemSource('https://dmoj.ca/problem/ciw26p2'), 'dmoj');
+  assert.equal(getProblemSource('https://www.dmoj.ca/problem/ciw26p2'), 'dmoj');
+});
+
 test('classifies ordinary Codeforces problem URLs', () => {
   assert.equal(getProblemSource('https://codeforces.com/problemset/problem/1/A'), 'codeforces');
 });
@@ -17,7 +22,9 @@ test('does not classify URLs by an untrusted hostname substring', () => {
     'https://evil.example/open.kattis.com/problems/hello',
     'https://open.kattis.com@evil.example/problems/hello',
     'https://evil.example/?next=https://open.kattis.com/problems/hello',
-    'not-a-url-containing-kattis.com'
+    'not-a-url-containing-kattis.com',
+    'https://dmoj.ca.evil.example/problem/ciw26p2',
+    'https://evil.example/?next=https://dmoj.ca/problem/ciw26p2'
   ]) {
     assert.equal(getProblemSource(url), 'codeforces');
   }
diff --git a/tests/runtime-composition.test.ts b/tests/runtime-composition.test.ts
index 8e27206..1369842 100644
--- a/tests/runtime-composition.test.ts
+++ b/tests/runtime-composition.test.ts
@@ -105,13 +105,16 @@ test('legacy provider routes redirect and user route preserves its parameter', (
 
 test('provider composition exposes concrete adapters in stable display order', () => {
   const adapters = createProviderAdapters();
-  assert.deepEqual(providerOrder, ['codeforces', 'kattis']);
+  assert.deepEqual(providerOrder, ['codeforces', 'kattis', 'dmoj']);
   assert.equal(adapters.codeforces.id, 'codeforces');
   assert.equal(adapters.kattis.id, 'kattis');
+  assert.equal(adapters.dmoj.id, 'dmoj');
   assert.match(adapters.codeforces.placeholder, /codeforces\.com/);
   assert.match(adapters.kattis.placeholder, /kattis/);
+  assert.match(adapters.dmoj.placeholder, /dmoj\.ca/);
   assert.equal(adapters.codeforces.extract('https://codeforces.com/contest/1/problem/A').length, 1);
   assert.equal(adapters.kattis.extract('open.kattis.com/problems/hello').length, 1);
+  assert.equal(adapters.dmoj.extract('https://dmoj.ca/problem/ciw26p2').length, 1);
 });
 
 test('composed singleton services preserve anonymous read and write guards', async () => {
diff --git a/tests/submit-provider-adapters.test.ts b/tests/submit-provider-adapters.test.ts
index 0a1837d..4ae814e 100644
--- a/tests/submit-provider-adapters.test.ts
+++ b/tests/submit-provider-adapters.test.ts
@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { createCodeforcesSubmitAdapter } from '../src/lib/submit/providers/codeforces.ts';
+import { createDmojSubmitAdapter } from '../src/lib/submit/providers/dmoj.ts';
 import { createKattisSubmitAdapter } from '../src/lib/submit/providers/kattis.ts';
 import type {
   ContestDraft,
@@ -117,7 +118,7 @@ test('Codeforces adapter accepts a bare fetch function as its dependency', async
   assert.equal(resolved.valid ? '' : resolved.reason, 'Authentication required');
 });
 
-test('provider adapters delegate commits by item kind and reject impossible Kattis contests', async () => {
+test('provider adapters delegate commits by item kind and reject impossible problem-only contests', async () => {
   const calls: string[] = [];
   const store = persistence({
     insertProblem: async () => (calls.push('problem'), { success: true }),
@@ -147,7 +148,14 @@ test('provider adapters delegate commits by item kind and reject impossible Katt
     success: false,
     message: 'Failed to add entry'
   });
-  assert.deepEqual(calls, ['problem', 'contest', 'problem']);
+
+  const dmoj = createDmojSubmitAdapter(store);
+  await dmoj.commit(problem);
+  assert.deepEqual(await dmoj.commit(contest), {
+    success: false,
+    message: 'Failed to add entry'
+  });
+  assert.deepEqual(calls, ['problem', 'contest', 'problem', 'problem']);
 });
 
 test('Kattis adapter fetches encoded canonical URL and parses successful HTML', async () => {
@@ -188,3 +196,45 @@ test('Kattis adapter falls back safely on proxy JSON, HTTP, and transport errors
     assert.equal(resolved.valid && resolved.payload.difficulty, undefined);
   }
 });
+
+test('DMOJ adapter fetches encoded canonical URL and parses the API payload', async () => {
+  let requested = '';
+  const adapter = createDmojSubmitAdapter(persistence(), async (input) => {
+    requested = String(input);
+    return Response.json({
+      problem: { data: { object: { name: "CIW '26 P2", types: ['Simulation'] } } }
+    });
+  });
+  const [entry] = adapter.extract('https://dmoj.ca/problem/ciw26p2');
+  const resolved = await adapter.resolve(entry, 'alice');
+  assert.equal(resolved.valid, true);
+  assert.equal(resolved.valid && resolved.payload.name, "CIW '26 P2");
+  assert.deepEqual(resolved.valid && resolved.kind === 'problem' ? resolved.payload.tags : null, [
+    'Simulation'
+  ]);
+  assert.equal(resolved.valid && resolved.payload.difficulty, undefined);
+  assert.equal(requested, '/api/dmoj?url=https%3A%2F%2Fdmoj.ca%2Fproblem%2Fciw26p2');
+});
+
+test('DMOJ adapter falls back to the problem code on proxy, HTTP, and transport errors', async () => {
+  const responses: Array<typeof fetch> = [
+    async () => Response.json({ error: 'blocked' }, { status: 403 }),
+    async () => Response.json({}, { status: 500 }),
+    async () => new Response('not-json'),
+    async () => Response.json({}),
+    async () => {
+      throw new Error('offline');
+    }
+  ];
+  for (const fetchProblem of responses) {
+    const adapter = createDmojSubmitAdapter(persistence(), fetchProblem);
+    const [entry] = adapter.extract('https://dmoj.ca/problem/ciw26p2');
+    const resolved = await adapter.resolve(entry, '');
+    assert.equal(resolved.valid, true);
+    assert.equal(resolved.valid && resolved.payload.name, 'ciw26p2');
+    assert.deepEqual(
+      resolved.valid && resolved.kind === 'problem' ? resolved.payload.tags : null,
+      []
+    );
+  }
+});
diff --git a/tests/submit-workflow.test.ts b/tests/submit-workflow.test.ts
index df0c964..d90a650 100644
--- a/tests/submit-workflow.test.ts
+++ b/tests/submit-workflow.test.ts
@@ -45,12 +45,17 @@ function adapter(overrides: Partial<ProviderAdapter> = {}): ProviderAdapter {
   };
 }
 
-function adapters(codeforces = adapter(), kattis = adapter({ id: 'kattis', name: 'Kattis' })) {
-  return { codeforces, kattis } as ProviderAdapters;
+function adapters(
+  codeforces = adapter(),
+  kattis = adapter({ id: 'kattis', name: 'Kattis' }),
+  dmoj = adapter({ id: 'dmoj', name: 'DMOJ' })
+) {
+  return { codeforces, kattis, dmoj } as ProviderAdapters;
 }
 
 test('initializes from a valid route provider and defaults invalid routes', () => {
   assert.equal(providerFromUrl(new URL('https://gitgud.test/submit?provider=kattis')), 'kattis');
+  assert.equal(providerFromUrl(new URL('https://gitgud.test/submit?provider=dmoj')), 'dmoj');
   assert.equal(providerFromUrl(new URL('https://gitgud.test/submit?provider=unknown')), undefined);
   assert.equal(createSubmissionWorkflow(adapters(), 'kattis').getState().provider, 'kattis');
   assert.equal(createSubmissionWorkflow(adapters()).getState().provider, 'codeforces');