diff --git a/db/migration/019-add-tunicwilds.sql b/db/migration/019-add-tunicwilds.sql
new file mode 100644
index 0000000..0779d9c
--- /dev/null
+++ b/db/migration/019-add-tunicwilds.sql
@@ -0,0 +1,10 @@
+CREATE TABLE "Tunicwild" (
+    "id" integer PRIMARY KEY AUTOINCREMENT,
+    "memberDiscord" text NOT NULL,
+    "composer" text NOT NULL,
+    "title" text NOT NULL,
+    "game" text NOT NULL,
+    "releaseDate" text NOT NULL,
+    "officialLink" text NOT NULL,
+    FOREIGN KEY ("memberDiscord") REFERENCES "Member" ("discord")
+);
diff --git a/development.sh b/development.sh
index 92ebeb5..cecd31b 100755
--- a/development.sh
+++ b/development.sh
@@ -13,22 +13,40 @@ export CORPORATE_URL=
 export DATABASE_URL="file:./$database"
 export DIGITALOCEAN_DNS_TOKEN=
 export LATEX_WEB_SYSTEMD_UNIT=
+export PUBLIC_DIRECTORY='public'
 export SECRET_HMAC_KEY='dev'
 export SIGHTS_RUN_AFTER_UPLOAD=
 export SIGHTS_UPLOAD_DIRECTORY='dev/sights'
 export SOUNDS_RUN_AFTER_UPLOAD=
 export SOUNDS_UPLOAD_DIRECTORY='dev/sounds'
+export TUNICWILDS_DAILY_FILE='dev/tunicwilds-daily.json'
+export TUNICWILDS_RENDERED_DIRECTORY='dev/tunicwilds-rendered'
+export TUNICWILDS_RUN_AFTER_RENDER=
+export TUNICWILDS_UPLOAD_DIRECTORY='dev/tunicwilds'
+export TUNICWILDS_UPLOAD_URL=
 export WORDS_RUN_AFTER_UPLOAD=
 export WORDS_UPLOAD_DIRECTORY='dev/words'
-export PUBLIC_DIRECTORY='public'
+
+if test $# -gt 0; then
+    exec "$@"
+fi
 
 # Clean up files from last run
-rm -rf "$database" "$SIGHTS_UPLOAD_DIRECTORY" "$SOUNDS_UPLOAD_DIRECTORY" "$WORDS_UPLOAD_DIRECTORY"
+rm -rf \
+    "$database" \
+    "$SIGHTS_UPLOAD_DIRECTORY" \
+    "$SOUNDS_UPLOAD_DIRECTORY" \
+    "$WORDS_UPLOAD_DIRECTORY" \
+    "$TUNICWILDS_DAILY_FILE" \
+    "$TUNICWILDS_RENDERED_DIRECTORY" \
+    "$TUNICWILDS_UPLOAD_DIRECTORY"
 
 # Create directories
 mkdir -p "$SIGHTS_UPLOAD_DIRECTORY"
 mkdir -p "$SOUNDS_UPLOAD_DIRECTORY"
 mkdir -p "$WORDS_UPLOAD_DIRECTORY"
+mkdir -p "$TUNICWILDS_RENDERED_DIRECTORY"
+mkdir -p "$TUNICWILDS_UPLOAD_DIRECTORY"
 
 # Create database
 node db/migrate.mjs "$database"
diff --git a/src/bin/start-tunicwild-day.ts b/src/bin/start-tunicwild-day.ts
new file mode 100644
index 0000000..b768a17
--- /dev/null
+++ b/src/bin/start-tunicwild-day.ts
@@ -0,0 +1,186 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { notInArray, sql } from "drizzle-orm";
+import db from "../database/db";
+import { Tunicwild } from "../database/schema";
+
+if (!process.env.TUNICWILDS_DAILY_FILE) {
+    console.error("TUNICWILDS_DAILY_FILE not set");
+    process.exit(1);
+}
+
+if (!process.env.TUNICWILDS_RENDERED_DIRECTORY) {
+    console.error("TUNICWILDS_RENDERED_DIRECTORY not set");
+    process.exit(1);
+}
+
+if (!process.env.TUNICWILDS_UPLOAD_URL && !process.env.TUNICWILDS_UPLOAD_DIRECTORY) {
+    console.error("TUNICWILDS_UPLOAD_* not set");
+    process.exit(1);
+}
+
+interface DailyInfo {
+    active: {
+        audioFilenames: string[];
+        date: string;
+        id: number;
+    }[];
+    recentIds: number[];
+    startDate: string;
+}
+
+const audioLengths = [0.5, 1, 2, 4, 8, 16] as const;
+
+async function renderAudio(id: number): Promise<string[]> {
+    let audioBuffer: NodeJS.ArrayBufferView;
+    if (process.env.TUNICWILDS_UPLOAD_URL) {
+        const response = await fetch(`${process.env.TUNICWILDS_UPLOAD_URL}/${id}`);
+        audioBuffer = await response.bytes();
+    } else if (process.env.TUNICWILDS_UPLOAD_DIRECTORY) {
+        audioBuffer = await readFile(join(process.env.TUNICWILDS_UPLOAD_DIRECTORY, id.toString()));
+    } else {
+        throw new Error();
+    }
+
+    const ffmpegStatsResult = spawnSync("ffmpeg", [
+        "-v", "quiet",
+        "-stats",
+        "-i", "pipe:",
+        "-map", "0:a:0",
+        "-f", "null",
+        "-",
+    ], {
+        encoding: "utf8",
+        input: audioBuffer,
+        stdio: ["pipe", "ignore", "pipe"],
+    });
+
+    if (ffmpegStatsResult.error != null) {
+        throw ffmpegStatsResult.error;
+    }
+
+    const timeMatch = ffmpegStatsResult.stderr.match(/time=(\d{2,}):(\d{2}):(\d{2}\.\d{2})[^\r]*$/);
+
+    if (timeMatch == null) {
+        throw new Error(`Unexpected ffmpeg output:\n${ffmpegStatsResult}`);
+    }
+
+    const durationSeconds =
+        Number.parseInt(timeMatch[1]!, 10) * 60 * 60 +
+        Number.parseInt(timeMatch[2]!, 10) * 60 +
+        Number.parseFloat(timeMatch[3]!);
+
+    const filenames = audioLengths.map(() => `${randomBytes(16).toString("hex")}.mp3`);
+    const maxAudioLength = audioLengths[audioLengths.length - 1]!;
+    const maxAudioLengthFilename = filenames[audioLengths.length - 1]!;
+
+    execFileSync("ffmpeg", [
+        "-v", "quiet",
+        "-ss", Math.max(0, Math.floor((durationSeconds - maxAudioLength) * Math.random())).toString(),
+        "-t", maxAudioLength.toString(),
+        "-i", "pipe:",
+        "-map", "0:a:0",
+        "-map_metadata", "-1",
+        "-c:a", "libmp3lame",
+        "-q:a", "0",
+        join(process.env.TUNICWILDS_RENDERED_DIRECTORY!, maxAudioLengthFilename),
+    ], {
+        input: audioBuffer,
+        stdio: ["pipe", "ignore", "ignore"],
+    });
+
+    for (let i = 0; i < audioLengths.length - 1; i++) {
+        execFileSync("ffmpeg", [
+            "-v", "quiet",
+            "-t", audioLengths[i]!.toString(),
+            "-i", join(process.env.TUNICWILDS_RENDERED_DIRECTORY!, maxAudioLengthFilename),
+            "-c", "copy",
+            join(process.env.TUNICWILDS_RENDERED_DIRECTORY!, filenames[i]!),
+        ], {
+            stdio: "ignore",
+        });
+    }
+
+    if (process.env.TUNICWILDS_RUN_AFTER_RENDER) {
+        execFileSync(
+            process.env.TUNICWILDS_RUN_AFTER_RENDER,
+            filenames.map(
+                (filename) => join(process.env.TUNICWILDS_RENDERED_DIRECTORY!, filename),
+            ),
+            { stdio: "ignore" },
+        );
+    }
+
+    return filenames;
+}
+
+// From "dist/server/bin/"
+process.chdir(resolve(import.meta.dirname, "../../.."));
+
+let dailyInfo: DailyInfo;
+try {
+    dailyInfo = JSON.parse(await readFile(process.env.TUNICWILDS_DAILY_FILE, "utf8"));
+} catch {
+    dailyInfo = {
+        active: [],
+        recentIds: [],
+        startDate: new Date().toISOString().slice(0, 10),
+    };
+}
+
+if (dailyInfo.active.length === 0) {
+    const tunicwilds = await db
+        .select()
+        .from(Tunicwild)
+        .orderBy(sql`RANDOM()`)
+        .limit(3);
+
+    if (tunicwilds.length !== 3) {
+        console.error("Not enough Tunicwilds in database");
+        process.exit(1);
+    }
+
+    for (let i = 0; i < tunicwilds.length; i++) {
+        dailyInfo.active.push({
+            audioFilenames: await renderAudio(tunicwilds[i]!.id),
+            date: new Date(Date.now() + (i - 1) * 1000 * 60 * 60 * 24).toISOString().slice(0, 10),
+            id: tunicwilds[i]!.id,
+        });
+        dailyInfo.recentIds.push(tunicwilds[i]!.id);
+    }
+} else {
+    const tunicwild = await db
+        .select()
+        .from(Tunicwild)
+        .where(notInArray(Tunicwild.id, dailyInfo.recentIds))
+        .orderBy(sql`RANDOM()`)
+        .get();
+
+    if (tunicwild == null) {
+        console.error("Not enough Tunicwilds in database");
+        process.exit(1);
+    }
+
+    dailyInfo.active.push({
+        audioFilenames: await renderAudio(tunicwild.id),
+        date: new Date(Date.now() + 1000 * 60 * 60 * 24).toISOString().slice(0, 10),
+        id: tunicwild.id,
+    });
+    dailyInfo.recentIds.push(tunicwild.id);
+
+    if (dailyInfo.active.length > 3) {
+        const dropped = dailyInfo.active.shift()!;
+
+        await Promise.all(dropped.audioFilenames.map(
+            (filename) => unlink(join(process.env.TUNICWILDS_RENDERED_DIRECTORY!, filename)),
+        ));
+    }
+
+    if (dailyInfo.recentIds.length > 30) {
+        dailyInfo.recentIds.shift();
+    }
+}
+
+await writeFile(process.env.TUNICWILDS_DAILY_FILE, JSON.stringify(dailyInfo));
diff --git a/src/components/Tunicwilds/Tunicwilds.svelte b/src/components/Tunicwilds/Tunicwilds.svelte
new file mode 100644
index 0000000..d673fdb
--- /dev/null
+++ b/src/components/Tunicwilds/Tunicwilds.svelte
@@ -0,0 +1,783 @@
+<script lang="ts">
+    import type { InferSelectModel } from "drizzle-orm";
+    import type { Tunicwild } from "../../database/schema";
+
+    type SongData = Pick<
+        InferSelectModel<typeof Tunicwild>,
+        "composer" | "game" | "id" | "officialLink" | "title"
+    >;
+
+    const date = new Date();
+
+    const { songList }: { songList: SongData[] } = $props();
+    const gameGroupedSongList = Object.groupBy(
+        songList,
+        (song) => song.game,
+    ) as Record<string, SongData[]>;
+
+    // server data
+    let songData = $state() as Awaited<ReturnType<typeof getSongData>>;
+    let currentGuess = $state({ id: -1, guess: "" });
+    let error = $state("");
+    let isPlaying = $state(false);
+    let showDropdown = $state(false);
+    let showSongList = $state(false);
+    let audioElement: HTMLAudioElement | null = $state(null);
+    let currentTime = $state(0);
+    let animationFrameId: number | null = null;
+
+    const clipLengths = [0.5, 1, 2, 4, 8, 16];
+    const maxGuesses = clipLengths.length;
+
+    const guesses = $derived(songData?.session.guesses ?? []);
+    const result = $derived(songData?.session.result ?? null);
+
+    const filterProperties = ["title", "game", "composer"] as const;
+    const filteredSongs = $derived(
+        currentGuess.guess.trim()
+            ? songList
+                  .filter((song) =>
+                      filterProperties.some((property) =>
+                          song[property]
+                              .toLowerCase()
+                              .includes(
+                                  currentGuess.guess.trim().toLowerCase(),
+                              ),
+                      ),
+                  )
+                  .sort((a, b) => {
+                      for (const property of filterProperties) {
+                          const comparison = a[property].localeCompare(
+                              b[property],
+                          );
+
+                          if (comparison) {
+                              return comparison;
+                          }
+                      }
+
+                      return 0;
+                  })
+                  .slice(0, 8)
+            : [],
+    );
+
+    $effect(() => {
+        if (currentGuess.guess.trim()) showDropdown = true;
+        else showDropdown = false;
+    });
+
+    // Unironically just for updating the current time of the audio for the progress bar
+    $effect(() => {
+        if (!audioElement) return;
+
+        const updateProgress = () => {
+            if (audioElement && !audioElement.paused) {
+                currentTime = audioElement.currentTime;
+                animationFrameId = requestAnimationFrame(updateProgress);
+            }
+        };
+
+        const handlePlay = () => {
+            isPlaying = true;
+            updateProgress();
+        };
+
+        const handlePause = () => {
+            isPlaying = false;
+            if (animationFrameId) {
+                cancelAnimationFrame(animationFrameId);
+                animationFrameId = null;
+            }
+            currentTime = audioElement!.currentTime;
+        };
+
+        const handleLoadedMetadata = () => {
+            currentTime = audioElement!.currentTime;
+        };
+
+        audioElement.addEventListener("play", handlePlay);
+        audioElement.addEventListener("pause", handlePause);
+        audioElement.addEventListener("ended", handlePause);
+        audioElement.addEventListener("loadedmetadata", handleLoadedMetadata);
+
+        return () => {
+            if (animationFrameId) {
+                cancelAnimationFrame(animationFrameId);
+            }
+            audioElement!.removeEventListener("play", handlePlay);
+            audioElement!.removeEventListener("pause", handlePause);
+            audioElement!.removeEventListener("ended", handlePause);
+            audioElement!.removeEventListener(
+                "loadedmetadata",
+                handleLoadedMetadata,
+            );
+        };
+    });
+
+    // Force reload the audio when the URL changes
+    $effect(() => {
+        if (audioElement && songData?.tunicwild.audioUrl) {
+            audioElement.load();
+            currentTime = 0;
+        }
+    });
+
+    if (!import.meta.env.SSR) {
+        getSongData()
+            .then((value) => (songData = value))
+            .catch((err) => {
+                console.error("Failed to fetch song data:", err);
+                error = `${err.message}`;
+            });
+    }
+
+    async function getSongData(): Promise<{
+        fourFourFiveEnabled: boolean;
+        session: Required<SessionData>["tunicwilds"][string];
+        tunicwild: Partial<
+            Omit<InferSelectModel<typeof Tunicwild>, "releaseDate">
+        > & {
+            audioUrl: string;
+            releaseDate?: string;
+        };
+    }> {
+        const adjustedTimestamp =
+            date.getTime() - new Date().getTimezoneOffset() * 60 * 1000;
+
+        const res = await fetch(
+            `/tunicwilds/today?timestamp=${adjustedTimestamp}`,
+        ).then((res) => res.json());
+
+        if (res.error) throw new Error(res.error);
+        return res;
+    }
+
+    async function submitGuess(guessId: number | null = null) {
+        if (!songData) return;
+
+        try {
+            const adjustedTimestamp =
+                date.getTime() - new Date().getTimezoneOffset() * 60 * 1000;
+
+            const response = await fetch("/tunicwilds/today", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    timestamp: adjustedTimestamp,
+                    guess: guessId,
+                }),
+            });
+
+            // The response contains the updated data regardless of redirect
+            const updatedData = await response.json();
+            if (updatedData.error) {
+                throw new Error(updatedData.error);
+            }
+            songData = updatedData;
+        } catch (err) {
+            console.error("Failed to submit guess:", err);
+            error = `Failed to submit guess: ${err}`;
+        }
+    }
+
+    async function selectSong(songTitle: { id: number; guess: string }) {
+        currentGuess = songTitle;
+        showDropdown = false;
+        await handleGuess(songTitle);
+    }
+
+    async function skipGuess() {
+        await submitGuess(null); // Submit null for skip
+        currentGuess = { id: -1, guess: "" };
+        showDropdown = false;
+    }
+
+    async function handleGuess(guessedSong = currentGuess) {
+        if (!guessedSong.guess.trim()) return;
+
+        const validSong = songList.find((song) => song.id === guessedSong.id);
+
+        if (!validSong) return;
+
+        await submitGuess(validSong.id);
+        currentGuess = { id: -1, guess: "" };
+        showDropdown = false;
+    }
+
+    function playClip() {
+        if (!audioElement) return;
+
+        audioElement.currentTime = 0;
+        audioElement.play();
+        isPlaying = true;
+    }
+
+    function pauseClip() {
+        if (!audioElement) return;
+
+        audioElement.currentTime = 0;
+        audioElement.pause();
+        isPlaying = false;
+    }
+
+    function shareResult() {
+        const emojiSet = songData.fourFourFiveEnabled
+            ? {
+                  skip: ":charles:",
+                  correct: ":onlinecharles:",
+                  correctGame: ":neoyellowcharles:",
+                  correctTitle: ":jamescharles:",
+                  incorrect: ":redcharles:",
+              }
+            : {
+                  skip: "🖤",
+                  correct: "💚",
+                  correctGame: "💛",
+                  correctTitle: "💙",
+                  incorrect: "💔",
+              };
+
+        const attempts = result ? guesses.length : "X";
+        const squares = guesses
+            .map((guess) => emojiSet[guess?.result ?? "skip"])
+            .join("");
+
+        const shareText = `Tunicwilds ${date.toLocaleDateString()} ${attempts}/${maxGuesses}\n\n${squares}`;
+
+        if (navigator.share) navigator.share({ text: shareText });
+        else {
+            navigator.clipboard.writeText(shareText);
+            alert("Results copied to clipboard!");
+        }
+    }
+
+    function handleClickOutside(event: MouseEvent) {
+        if (!(event.target as HTMLElement).closest(".dropdown-container"))
+            showDropdown = false;
+
+        if (
+            showSongList &&
+            event.target instanceof HTMLDivElement &&
+            event.target.classList.contains("song-list-overlay")
+        ) {
+            event.preventDefault();
+            showSongList = false;
+        }
+    }
+
+    function handleKeydown(event: KeyboardEvent): void {
+        if (showSongList && event.key === "Escape") {
+            event.preventDefault();
+            showSongList = false;
+        }
+    }
+</script>
+
+<svelte:window on:click={handleClickOutside} onkeydown={handleKeydown} />
+
+<div class="container">
+    <!-- Header -->
+    <div class="header">
+        <h1>TUNICWILDS</h1>
+        <p class="subtitle">Guess the song from the game</p>
+        <p class="game-info">
+            {date.toLocaleDateString()} • {guesses.length}/{maxGuesses} guesses
+        </p>
+        <button
+            class="song-list-btn"
+            onclick={() => (showSongList = !showSongList)}
+        >
+            {showSongList ? "Hide Song List" : "Show Song List"}
+        </button>
+    </div>
+
+    {#if showSongList}
+        <div class="song-list-overlay">
+            <div class="song-list">
+                <h2>Song List</h2>
+                <button
+                    class="close-btn"
+                    onclick={() => (showSongList = false)}
+                >
+                    Close
+                </button>
+                {#each Object.entries(gameGroupedSongList) as [game, songs]}
+                    <div class="game-section">
+                        <h3>{game}</h3>
+                        <ul>
+                            {#each songs as song}
+                                <li>
+                                    <a href={song.officialLink} target="_blank">
+                                        {song.composer} - "{song.title}"
+                                    </a>
+                                </li>
+                            {/each}
+                        </ul>
+                    </div>
+                {/each}
+            </div>
+        </div>
+    {/if}
+
+    {#if error}
+        <p>Error: {error}</p>
+    {:else if songData == null}
+        <p>Loading today's song...</p>
+    {:else}
+        <!-- Game Over - Answer Display (Top) -->
+        {#if result != null}
+            <div class="game-over">
+                <div class="result">
+                    {#if result}
+                        <p class="result-message result-message--win">
+                            😃 Nice
+                        </p>
+                        <p>
+                            You guessed it in {guesses.length}
+                            {guesses.length === 1 ? "try" : "tries"}!
+                        </p>
+                    {:else}
+                        <p class="result-message result-message--lose">
+                            😔 Game Over
+                        </p>
+                        <p>Better luck next time!</p>
+                    {/if}
+                </div>
+
+                <a
+                    class="answer-display answer-display--{result
+                        ? 'win'
+                        : 'lose'}"
+                    href={songData.tunicwild.officialLink}
+                    target="_blank"
+                >
+                    <span>
+                        {songData.tunicwild.composer} - "{songData.tunicwild
+                            .title}"
+                    </span>
+                    <strong>{songData.tunicwild.game}</strong>
+                </a>
+
+                <div class="game-over-buttons">
+                    <button onclick={shareResult} class="share-btn">
+                        Share Result
+                    </button>
+                </div>
+            </div>
+        {/if}
+
+        <!-- Guesses List -->
+        <div class="guesses-list">
+            <h3>Your Guesses:</h3>
+            <div class="guesses">
+                {#each Array(maxGuesses) as _, index}
+                    {@const guess = guesses[index]}
+                    {@const guessedSong = songList.find(
+                        (song) => song.id === guess?.id,
+                    )}
+
+                    <div
+                        class={[
+                            "guess-item",
+                            `guess-item--${guess === undefined ? "empty" : (guess?.result ?? "skip")}`,
+                        ]}
+                    >
+                        <div class="guess-content">
+                            {#if guessedSong != null}
+                                <a
+                                    class="guess-title"
+                                    href={guessedSong.officialLink}
+                                    >{guessedSong.composer} - "{guessedSong.title}"
+                                    ({guessedSong.game})</a
+                                >
+                            {:else}
+                                <div class="guess-title">
+                                    {guess === undefined
+                                        ? "—"
+                                        : guess == null
+                                          ? "Skipped"
+                                          : "Song unavailable"}
+                                </div>
+                            {/if}
+                            <span class="clip-duration">
+                                {clipLengths[index]}s
+                            </span>
+                        </div>
+                    </div>
+                {/each}
+            </div>
+        </div>
+
+        <!-- Audio Player -->
+        <div class="audio-player">
+            {#if result == null}
+                <div class="audio-info">
+                    <div class="clip-info">
+                        Clip length: {clipLengths[guesses.length]}s
+                    </div>
+                    <div class="attempt-info">
+                        Attempt {guesses.length + 1} of {maxGuesses}
+                    </div>
+                </div>
+            {/if}
+
+            <div class="audio-controls">
+                <button
+                    onclick={isPlaying ? pauseClip : playClip}
+                    class="play-btn"
+                >
+                    {isPlaying ? "⏹️ Stop" : "▶️ Play"}
+                </button>
+            </div>
+
+            <!-- Hints -->
+            {#if result == null}
+                {#if songData.tunicwild.releaseDate != null}
+                    <div class="hint">
+                        💡 <strong>Hint:</strong> This song was released on
+                        <strong
+                            >{new Date(
+                                songData.tunicwild.releaseDate,
+                            ).toLocaleDateString(undefined, {
+                                dateStyle: "long",
+                                timeZone: "UTC",
+                            })}</strong
+                        >
+                    </div>
+                {/if}
+
+                {#if songData.tunicwild.game != null && !guesses.some((guess) => guess?.result === "correctGame")}
+                    <div class="hint">
+                        💡 <strong>Hint:</strong> This song is from
+                        <strong>{songData.tunicwild.game}</strong>
+                    </div>
+                {/if}
+            {/if}
+
+            <!-- Progress bar -->
+            <div class="progress-bar">
+                {#each clipLengths as length}
+                    <div
+                        class="progress-marker"
+                        style="left: {(length / 16) * 100}%"
+                    ></div>
+                {/each}
+                <div
+                    class="progress-fill"
+                    style="width: {(currentTime / 16) * 100}%"
+                ></div>
+            </div>
+
+            <audio bind:this={audioElement} preload="auto">
+                <source src={songData.tunicwild.audioUrl} type="audio/mp3" />
+            </audio>
+        </div>
+
+        <!-- Guess Input with Autocomplete -->
+        {#if result == null}
+            <div class="guess-input dropdown-container">
+                <p class="input-hint">
+                    You must select from the autocomplete suggestions
+                </p>
+                <div class="input-wrapper">
+                    <input
+                        type="text"
+                        bind:value={currentGuess.guess}
+                        onfocus={() =>
+                            currentGuess.guess.trim() && (showDropdown = true)}
+                        placeholder="Start typing a song title..."
+                    />
+                    <span class="dropdown-arrow">⌄</span>
+                </div>
+
+                <!-- Autocomplete Dropdown -->
+                {#if showDropdown && filteredSongs.length > 0}
+                    <div class="dropdown">
+                        {#each filteredSongs as song}
+                            <button
+                                onclick={() =>
+                                    selectSong({
+                                        id: song.id,
+                                        guess: song.title,
+                                    })}
+                                class="dropdown-item"
+                            >
+                                <div class="song-title">
+                                    {song.composer} - "{song.title}" ({song.game})
+                                </div>
+                            </button>
+                        {/each}
+                    </div>
+                {/if}
+
+                <!-- Skip -->
+                <button onclick={skipGuess} class="skip-btn">Skip</button>
+            </div>
+        {/if}
+    {/if}
+</div>
+
+<style>
+    .container {
+        min-height: 100vh;
+        max-width: 42rem;
+        margin: 0 auto;
+    }
+
+    .header {
+        text-align: center;
+    }
+
+    .song-list-overlay {
+        position: fixed;
+        inset: 0;
+        background: color-mix(
+            in srgb,
+            var(--background-color) 95%,
+            transparent
+        );
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        z-index: 1;
+    }
+
+    .song-list {
+        overflow-y: auto;
+        max-height: 100%;
+    }
+
+    .game-over {
+        text-align: center;
+        margin: 1.5rem auto;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        border: 1px dashed var(--text-color);
+        width: max-content;
+        padding: 1rem;
+    }
+
+    .answer-display {
+        padding: 1rem;
+        margin-bottom: 1rem;
+        text-decoration: none;
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+        border: 1px solid;
+        font-size: 1.25rem;
+    }
+
+    .answer-display:hover {
+        text-decoration: underline;
+    }
+
+    .answer-display > strong {
+        font-size: 0.8em;
+    }
+
+    .result-message {
+        font-size: 1.25rem;
+    }
+
+    .result-message--win {
+        color: #22c55e;
+    }
+
+    .result-message--lose {
+        color: #ef4444;
+    }
+
+    .result p {
+        margin-top: 0;
+        margin-bottom: 1rem;
+    }
+
+    .game-over-buttons {
+        display: flex;
+        justify-content: center;
+        gap: 1rem;
+    }
+
+    .share-btn {
+        font-weight: 600;
+        cursor: pointer;
+    }
+
+    .audio-info {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 1rem;
+    }
+
+    .audio-controls {
+        display: flex;
+        justify-content: center;
+        gap: 1rem;
+        margin-bottom: 1rem;
+    }
+
+    .play-btn {
+        font-weight: 600;
+        cursor: pointer;
+    }
+
+    .play-btn:disabled {
+        cursor: not-allowed;
+    }
+
+    .hint {
+        margin-block: 0.5em;
+    }
+
+    .progress-bar {
+        position: relative;
+        width: 100%;
+        height: 0.5rem;
+    }
+
+    .progress-marker {
+        position: absolute;
+        width: 0.125rem;
+        height: 0.5rem;
+        background: var(--text-color);
+    }
+
+    .progress-fill {
+        height: 0.5rem;
+        background: var(--text-color);
+    }
+
+    .guess-input {
+        padding: 1.5rem;
+        margin-bottom: 1.5rem;
+        position: relative;
+    }
+
+    .input-wrapper {
+        display: flex;
+        align-items: center;
+        position: relative;
+    }
+
+    .dropdown-arrow {
+        position: absolute;
+        right: 1rem;
+        pointer-events: none;
+    }
+
+    .dropdown {
+        position: absolute;
+        top: 100%;
+        left: 0;
+        right: 0;
+        margin-top: 0.25rem;
+        max-height: 15rem;
+        overflow-y: auto;
+        z-index: 10;
+    }
+
+    .dropdown-item {
+        width: 100%;
+        text-align: left;
+        padding: 0.5rem 1rem;
+        background: none;
+        border: none;
+        cursor: pointer;
+    }
+
+    .dropdown-item:last-child {
+        border-bottom: none;
+    }
+
+    .input-hint {
+        margin-top: 0.5rem;
+        margin-bottom: 0;
+    }
+
+    .guesses-list {
+        margin-bottom: 1.5rem;
+    }
+
+    .guesses {
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+
+    .guess-item {
+        padding: 0.5rem;
+        border: 1px solid;
+    }
+
+    .guess-item--correct,
+    .answer-display--win {
+        background: rgba(34, 197, 94, 0.3);
+        border-color: rgb(34, 197, 94);
+    }
+
+    .guess-item--correctGame,
+    .guess-item--correctTitle {
+        position: relative;
+    }
+
+    .guess-item--correctGame::after,
+    .guess-item--correctTitle::after {
+        position: absolute;
+        left: -45px;
+        top: -9px;
+        transform: rotate(-10deg);
+    }
+
+    .guess-item--correctGame {
+        background: rgba(231, 220, 65, 0.3);
+        border-color: rgb(231, 220, 65);
+    }
+
+    .guess-item--correctGame::after {
+        content: "Game correct!";
+        background-color: rgb(231, 220, 65);
+    }
+
+    .guess-item--correctTitle {
+        background: rgba(65, 131, 231, 0.3);
+        border-color: rgb(65, 131, 231);
+    }
+
+    .guess-item--correctTitle::after {
+        content: "Title correct!";
+        background-color: rgb(65, 131, 231);
+    }
+
+    .guess-item--incorrect,
+    .answer-display--lose {
+        background: rgba(239, 68, 68, 0.3);
+        border-color: rgb(239, 68, 68);
+    }
+
+    .guess-item--skip {
+        background: rgba(107, 114, 128, 0.1);
+        border-color: rgb(209, 213, 219);
+    }
+
+    .guess-item--empty {
+        background: rgba(107, 114, 128, 0.1);
+        border-color: rgb(209, 213, 219);
+        opacity: 0.5;
+    }
+
+    .guess-content {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+    }
+
+    .skip-btn {
+        margin-top: 0.5rem;
+    }
+</style>
diff --git a/src/database/factories.ts b/src/database/factories.ts
index e70abd6..309d43c 100644
--- a/src/database/factories.ts
+++ b/src/database/factories.ts
@@ -1,6 +1,6 @@
 import { faker } from "@faker-js/faker";
 import defineFactory from "./defineFactory";
-import { Action, ActionItem, Member, Motion, Session, Sight, Sound, Ticket, Word } from "./schema";
+import { Action, ActionItem, Member, Motion, Session, Sight, Sound, Ticket, Tunicwild, Word } from "./schema";
 
 function unique<T>(fn: () => T): () => T {
     const used = new Set<T>();
@@ -83,6 +83,15 @@ export const TicketFactory = defineFactory(Ticket, {
     hash: () => faker.string.alphanumeric(32),
 });
 
+export const TunicwildFactory = defineFactory(Tunicwild, {
+    memberDiscord: () => { throw new Error("Not implemented"); },
+    composer: () => faker.person.firstName(),
+    title: () => faker.music.songName(),
+    game: () => faker.commerce.productName(),
+    releaseDate: () => faker.date.past(),
+    officialLink: () => faker.internet.url(),
+});
+
 export const WordFactory = defineFactory(Word, {
     title: () => faker.book.title(),
     memberDiscord: () => { throw new Error("Not implemented"); },
diff --git a/src/database/schema.ts b/src/database/schema.ts
index 9f4f58d..6d205bb 100644
--- a/src/database/schema.ts
+++ b/src/database/schema.ts
@@ -1,6 +1,5 @@
 import { relations, sql } from "drizzle-orm";
 import { sqliteTable, integer, text, customType, uniqueIndex } from "drizzle-orm/sqlite-core";
-import type { SessionData } from "../server/session";
 
 const date = customType<{ data: Date; driverData: string }>({
     dataType: () => "text",
@@ -63,6 +62,7 @@ export const MemberRelations = relations(Member, ({ many }) => ({
     sights: many(Sight),
     sounds: many(Sound),
     tickets: many(Ticket),
+    tunicwilds: many(Tunicwild),
     words: many(Word),
 }));
 
@@ -146,6 +146,23 @@ export const TicketRelations = relations(Ticket, ({ one }) => ({
     }),
 }));
 
+export const Tunicwild = sqliteTable("Tunicwild", {
+    id: integer().primaryKey({ autoIncrement: true }),
+    memberDiscord: text().notNull().references(() => Member.discord),
+    composer: text().notNull(),
+    title: text().notNull(),
+    game: text().notNull(),
+    releaseDate: date().notNull(),
+    officialLink: text().notNull(),
+});
+
+export const TunicwildRelations = relations(Tunicwild, ({ one }) => ({
+    member: one(Member, {
+        fields: [Tunicwild.memberDiscord],
+        references: [Member.discord],
+    }),
+}));
+
 export const Word = sqliteTable("Word", {
     id: integer().primaryKey({ autoIncrement: true }),
     title: text().notNull(),
diff --git a/src/database/seed.ts b/src/database/seed.ts
index 95dc4fe..281ad28 100644
--- a/src/database/seed.ts
+++ b/src/database/seed.ts
@@ -1,5 +1,11 @@
 import { faker } from "@faker-js/faker";
-import { ActionFactory, ActionItemFactory, MemberFactory, MotionFactory, SightFactory, SoundFactory, WordFactory } from "./factories";
+import { ActionFactory, ActionItemFactory, MemberFactory, MotionFactory, SightFactory, SoundFactory, TunicwildFactory, WordFactory } from "./factories";
+import { writeFile } from "fs/promises";
+import { join } from "path";
+
+if (!process.env.TUNICWILDS_UPLOAD_DIRECTORY) {
+    throw new Error("TUNICWILDS_UPLOAD_DIRECTORY not set");
+}
 
 export default async function seed() {
     const members = await new MemberFactory().count(20).create();
@@ -43,4 +49,18 @@ export default async function seed() {
     await new WordFactory().count(10).create({
         memberDiscord: () => faker.helpers.arrayElement(members.map((member) => member.discord)),
     });
+
+    const tunicwilds = await new TunicwildFactory().count(10).create({
+        memberDiscord: () => faker.helpers.arrayElement(members.map((member) => member.discord)),
+    });
+
+    const placeholderAudioResponse = await fetch("https://interactive-examples.mdn.mozilla.net/media/cc0-audio/t-rex-roar.mp3");
+    const placeholderAudio = await placeholderAudioResponse.bytes();
+
+    for (const tunicwild of tunicwilds) {
+        await writeFile(
+            join(process.env.TUNICWILDS_UPLOAD_DIRECTORY!, tunicwild.id.toString()),
+            placeholderAudio,
+        );
+    }
 }
diff --git a/src/database/utils.ts b/src/database/utils.ts
new file mode 100644
index 0000000..c1f1d12
--- /dev/null
+++ b/src/database/utils.ts
@@ -0,0 +1,14 @@
+import { SQL, sql } from "drizzle-orm";
+import type { SQLiteColumn } from "drizzle-orm/sqlite-core";
+
+export function lower(column: SQLiteColumn | string): SQL {
+    return sql`lower(${column})`;
+}
+
+export function upper(column: SQLiteColumn | string): SQL {
+    return sql`upper(${column})`;
+}
+
+export function like(column: SQLiteColumn | string, value: string): SQL {
+    return sql`${column} LIKE ${value}`;
+}
\ No newline at end of file
diff --git a/src/middleware.ts b/src/middleware.ts
index dde5b8f..6332a96 100644
--- a/src/middleware.ts
+++ b/src/middleware.ts
@@ -9,7 +9,11 @@ const checkHmacForApi = defineMiddleware(async (context, next) => {
         return next();
     }
 
-    if (context.url.pathname.startsWith("/api/action") && context.request.method === "GET") {
+    if (
+        (
+            context.url.pathname.startsWith("/api/action") ||
+            context.url.pathname.startsWith("/api/tunicwild")
+        ) && context.request.method === "GET") {
         return next();
     }
 
@@ -59,6 +63,10 @@ const serveUploadedFilesInDev = defineMiddleware(async (context, next) => {
         return new Response("SOUNDS_UPLOAD_DIRECTORY not set", { status: 500 });
     }
 
+    if (!process.env.TUNICWILDS_RENDERED_DIRECTORY) {
+        return new Response("TUNICWILDS_RENDERED_DIRECTORY not set", { status: 500 });
+    }
+
     if (!process.env.WORDS_UPLOAD_DIRECTORY) {
         return new Response("WORDS_UPLOAD_DIRECTORY not set", { status: 500 });
     }
@@ -66,6 +74,7 @@ const serveUploadedFilesInDev = defineMiddleware(async (context, next) => {
     const rewrites = [
         ["/sights-uploads/", process.env.SIGHTS_UPLOAD_DIRECTORY + "/"],
         ["/sounds-uploads/", process.env.SOUNDS_UPLOAD_DIRECTORY + "/"],
+        ["/tunicwilds-rendered/", process.env.TUNICWILDS_RENDERED_DIRECTORY + "/"],
         ["/words-uploads/", process.env.WORDS_UPLOAD_DIRECTORY + "/"],
     ] as const;
 
diff --git a/src/pages/api/tunicwilds/games.ts b/src/pages/api/tunicwilds/games.ts
new file mode 100644
index 0000000..d8c2f96
--- /dev/null
+++ b/src/pages/api/tunicwilds/games.ts
@@ -0,0 +1,18 @@
+import type { APIRoute } from "astro";
+import db from "../../../database/db";
+import { Tunicwild } from "../../../database/schema";
+import { jsonResponse } from "../../../server/responses";
+
+export const prerender = false;
+
+export const GET: APIRoute = async () => {
+    return jsonResponse(
+        await db
+            .select({
+                game: Tunicwild.game
+            })
+            .from(Tunicwild)
+            .groupBy(Tunicwild.game)
+            .orderBy(Tunicwild.game),
+    );
+};
diff --git a/src/pages/api/tunicwilds/index.ts b/src/pages/api/tunicwilds/index.ts
new file mode 100644
index 0000000..b9b983a
--- /dev/null
+++ b/src/pages/api/tunicwilds/index.ts
@@ -0,0 +1,251 @@
+import { join } from "node:path";
+import { LibsqlError } from "@libsql/client";
+import type { APIRoute } from "astro";
+import { and, eq, type InferSelectModel, type SQLWrapper } from "drizzle-orm";
+import { jsonError, jsonResponse } from "../../../server/responses";
+import db, { retryIfDbBusy } from "../../../database/db";
+import { Member, Tunicwild } from "../../../database/schema";
+import { paginationQuery, parseNumberCursor } from "../../../server/pagination";
+import { writeBlobToFile } from "../../../server/webApi";
+import { lower } from "../../../database/utils";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url }) => {
+    const conditions: SQLWrapper[] = [];
+    const params = url.searchParams;
+
+    const game = params.get("game");
+    if (game)
+        conditions.push(eq(lower(Tunicwild.game), lower(game)));
+
+    const composer = params.get("composer");
+    if (composer)
+        conditions.push(eq(lower(Tunicwild.composer), lower(composer)));
+
+    const title = params.get("title");
+    if (title)
+        conditions.push(eq(lower(Tunicwild.title), lower(title)));
+
+    const releaseDate = params.get("releaseDate");
+    if (releaseDate) {
+        const date = new Date(releaseDate);
+        if (isNaN(date.getTime()))
+            return jsonError("Invalid release date");
+        conditions.push(eq(Tunicwild.releaseDate, date));
+    }
+
+    return paginationQuery(
+        params,
+        Tunicwild,
+        "id",
+        parseNumberCursor,
+        ...conditions,
+    );
+}
+
+export const POST: APIRoute = async (context) => {
+    if (!process.env.TUNICWILDS_UPLOAD_URL && !process.env.TUNICWILDS_UPLOAD_DIRECTORY) {
+        return jsonError("TUNICWILDS_UPLOAD_* not set", 500);
+    }
+
+    let formData: FormData;
+    try {
+        formData = await context.request.formData();
+    } catch {
+        return jsonError("Request body must be form data");
+    }
+
+    const discord = formData.get("discord");
+    const composer = formData.get("composer");
+    const title = formData.get("title");
+    const game = formData.get("game");
+    const releaseDate = formData.get("releaseDate");
+    const officialLink = formData.get("officialLink");
+    const file = formData.get("file") as File;
+
+    if (typeof discord !== "string" || !discord) {
+        return jsonError("Member discord is required");
+    }
+    if (typeof composer !== "string" || !composer.trim()) {
+        return jsonError("Composer is required");
+    }
+    if (typeof title !== "string" || !title.trim()) {
+        return jsonError("Title is required");
+    }
+    if (typeof game !== "string" || !game.trim()) {
+        return jsonError("Game is required");
+    }
+    if (typeof releaseDate !== "string" || !releaseDate.trim()) {
+        return jsonError("Release date is required");
+    }
+    if (typeof officialLink !== "string" || !officialLink.trim()) {
+        return jsonError("Official link is required");
+    }
+    if (!(file instanceof File) || file.size === 0) {
+        return jsonError("Valid audio file is required");
+    }
+
+    // Parse and validate release date
+    const releaseDateParsed = new Date(releaseDate);
+    if (isNaN(releaseDateParsed.getTime())) {
+        return jsonError("Invalid release date format. Use YYYY-MM-DD or ISO format");
+    }
+    if (releaseDateParsed.getTime() > Date.now()) {
+        return jsonError("Release date cannot be in the future");
+    }
+
+    // Length validation with better limits
+    const MAX_LENGTH = 2 ** 10;
+    if (composer.length > MAX_LENGTH) {
+        return jsonError(`Composer name too long (max ${MAX_LENGTH} characters)`);
+    }
+    if (title.length > MAX_LENGTH) {
+        return jsonError(`Title too long (max ${MAX_LENGTH} characters)`);
+    }
+    if (game.length > MAX_LENGTH) {
+        return jsonError(`Game name too long (max ${MAX_LENGTH} characters)`);
+    }
+
+    // File validation with size limits
+    const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+    if (file.size > MAX_FILE_SIZE) {
+        return jsonError("File too large (max 50MB)");
+    }
+
+    const member = await db
+        .select()
+        .from(Member)
+        .where(eq(Member.discord, discord))
+        .get();
+
+    if (member == null) {
+        return jsonError("Member does not exist");
+    }
+
+    if (member.deleted) {
+        return jsonError("Member has been deleted");
+    }
+
+    // More robust file type checking
+    const allowedExtensions = [".ogg", ".opus", ".wav", ".mp3"];
+    const allowedMimeTypes = ["audio/ogg", "audio/opus", "audio/wav", "audio/mpeg", "audio/mp3"];
+
+    const fileExtension = file.name.toLowerCase().substring(file.name.lastIndexOf('.'));
+    const isValidExtension = allowedExtensions.includes(fileExtension);
+    const isValidMimeType = allowedMimeTypes.includes(file.type.toLowerCase());
+
+    if (!isValidExtension && !isValidMimeType) {
+        return jsonError("File must be an OGG, Opus, WAV, or MP3 file");
+    }
+
+    // Check for duplicates with case-insensitive comparison
+    const existingTunicwild = await db
+        .select()
+        .from(Tunicwild)
+        .where(
+            and(
+                eq(lower(Tunicwild.title), lower(title.trim())),
+                eq(lower(Tunicwild.game), lower(game.trim()))
+            )
+        )
+        .get();
+
+    if (existingTunicwild) {
+        return jsonError(`A song with title "${title}" already exists in game "${game}"`);
+    }
+
+    // Store to DB
+    let tunicwild: InferSelectModel<typeof Tunicwild>;
+    try {
+        tunicwild = await retryIfDbBusy(() =>
+            db
+                .insert(Tunicwild)
+                .values({
+                    memberDiscord: discord,
+                    composer: composer.trim(),
+                    title: title.trim(),
+                    game: game.trim(),
+                    releaseDate: releaseDateParsed,
+                    officialLink: officialLink.trim(),
+                })
+                .returning()
+                .get()
+        );
+    } catch (error) {
+        if (error instanceof LibsqlError) {
+            if (error.code === "SQLITE_CONSTRAINT_UNIQUE") {
+                return jsonError("A song with this title and game already exists");
+            }
+            if (error.code === "SQLITE_CONSTRAINT_FOREIGNKEY") {
+                return jsonError("Invalid foreign key constraint");
+            }
+        }
+        console.error("Database error:", error);
+        return jsonError("Failed to save song to database", 500);
+    }
+
+    // Upload files with better error handling
+    try {
+        if (process.env.TUNICWILDS_UPLOAD_DIRECTORY) {
+            await writeBlobToFile(
+                join(process.env.TUNICWILDS_UPLOAD_DIRECTORY, tunicwild.id.toString()),
+                file,
+            );
+        } else if (process.env.TUNICWILDS_UPLOAD_URL) {
+            const uploadResponse = await fetch(
+                `${process.env.TUNICWILDS_UPLOAD_URL}/upload/${tunicwild.id}`,
+                {
+                    method: "PUT",
+                    body: file,
+                    headers: {
+                        "Content-Length": file.size.toString(),
+                    },
+                }
+            );
+
+            if (!uploadResponse.ok) {
+                // If timed out, retry a few times
+                if (uploadResponse.status === 408 || uploadResponse.status === 504) {
+                    for (let i = 0; i < 3; i++) {
+                        const retryResponse = await fetch(
+                            `${process.env.TUNICWILDS_UPLOAD_URL}/upload/${tunicwild.id}`,
+                            {
+                                method: "PUT",
+                                body: file,
+                                headers: {
+                                    "Content-Length": file.size.toString(),
+                                },
+                            }
+                        );
+                        if (retryResponse.ok)
+                            break;
+
+                        if (i === 2) {
+                            // Rollback database entry if all retries fail
+                            await db.delete(Tunicwild).where(eq(Tunicwild.id, tunicwild.id));
+                            return jsonError(`Failed to upload file after retries: ${retryResponse.statusText}`, 500);
+                        }
+                    }
+                } else {
+                    // Rollback database entry if file upload fails
+                    await db.delete(Tunicwild).where(eq(Tunicwild.id, tunicwild.id));
+                    return jsonError(`Failed to upload file: ${uploadResponse.statusText}`, 500);
+                }
+            }
+        } else {
+            return jsonError("", 500);
+        }
+    } catch (error) {
+        console.error("File upload error:", error);
+        // Rollback database entry if file upload fails
+        try {
+            await db.delete(Tunicwild).where(eq(Tunicwild.id, tunicwild.id));
+        } catch (rollbackError) {
+            console.error("Failed to rollback database entry:", rollbackError);
+        }
+        return jsonError("Failed to upload audio file", 500);
+    }
+
+    return jsonResponse(tunicwild);
+};
diff --git a/src/pages/corp/sso/perform.ts b/src/pages/corp/sso/perform.ts
index 73e2df5..66ca857 100644
--- a/src/pages/corp/sso/perform.ts
+++ b/src/pages/corp/sso/perform.ts
@@ -7,6 +7,12 @@ import { jsonError } from "../../../server/responses";
 
 export const prerender = false;
 
+declare global {
+    interface SessionData {
+        memberDiscord?: string;
+    }
+}
+
 export const POST: APIRoute = async (context) => {
     let formData: FormData;
     try {
diff --git a/src/pages/things.astro b/src/pages/things.astro
index 635c38b..53ae30c 100644
--- a/src/pages/things.astro
+++ b/src/pages/things.astro
@@ -12,6 +12,7 @@ import Layout from "../layouts/Layout.astro";
         features/content
     </p>
     <ul>
+        <li><a href="/tunicwilds">Tunicwilds</a></li>
         <li><a href="/visions">Visions</a></li>
         <li><a href="/sensations">Sensations</a></li>
     </ul>
diff --git a/src/pages/tunicwilds/index.astro b/src/pages/tunicwilds/index.astro
new file mode 100644
index 0000000..25d3392
--- /dev/null
+++ b/src/pages/tunicwilds/index.astro
@@ -0,0 +1,25 @@
+---
+import Layout from "../../layouts/Layout.astro";
+import TunicwildsApp from "../../components/Tunicwilds/Tunicwilds.svelte";
+import db from "../../database/db";
+import { Tunicwild } from "../../database/schema";
+
+export const prerender = false;
+
+const songList = await db
+    .select({
+        id: Tunicwild.id,
+        composer: Tunicwild.composer,
+        game: Tunicwild.game,
+        officialLink: Tunicwild.officialLink,
+        title: Tunicwild.title,
+    })
+    .from(Tunicwild);
+---
+
+<Layout
+    title="Tunicwilds"
+    description="CAN YOU GUESS THE SONG? CAN YOU GUESS THE GAME? CAN YOU GUESS THE TUNICWILDS?"
+>
+    <TunicwildsApp client:load {songList} />
+</Layout>
diff --git a/src/pages/tunicwilds/today.ts b/src/pages/tunicwilds/today.ts
new file mode 100644
index 0000000..5f79e49
--- /dev/null
+++ b/src/pages/tunicwilds/today.ts
@@ -0,0 +1,190 @@
+import type { APIRoute } from "astro";
+import { jsonError, jsonResponse } from "../../server/responses";
+import db from "../../database/db";
+import { Tunicwild } from "../../database/schema";
+import { eq, type InferSelectModel } from "drizzle-orm";
+import { readFile } from "node:fs/promises";
+
+export const prerender = false;
+
+if (!process.env.TUNICWILDS_DAILY_FILE) {
+    throw new Error("TUNICWILDS_DAILY_FILE not set");
+}
+
+declare global {
+    interface SessionData {
+        tunicwilds?: Record<string, {
+            guesses: ({
+                id: number;
+                result: "correct" | "correctGame" | "correctTitle" | "incorrect";
+            } | null)[];
+            result: boolean | null;
+        }>;
+    }
+}
+
+interface DailyInfo {
+    active: {
+        audioFilenames: string[];
+        date: string;
+        id: number;
+    }[];
+    recentIds: number[];
+    startDate: string;
+}
+
+export const GET: APIRoute = async (context) => {
+    const date = new Date(Number.parseInt(context.url.searchParams.get("timestamp") ?? "", 10));
+
+    if (Number.isNaN(date.getTime())) {
+        return jsonError("Invalid timestamp");
+    }
+
+    let dailyInfo: DailyInfo;
+    try {
+        dailyInfo = JSON.parse(await readFile(process.env.TUNICWILDS_DAILY_FILE!, "utf8"));
+    } catch (error) {
+        console.error("Failed to read or parse daily tunicwilds file:", error);
+        return jsonError("Failed to read daily tunicwilds file");
+    }
+    const tunicwildDateString = date.toISOString().slice(0, 10);
+    const tunicwildInfo = dailyInfo.active.find((info) => info.date === tunicwildDateString);
+
+    if (tunicwildInfo == null) {
+        return jsonError("Invalid date. Check if your system clock is set correctly");
+    }
+
+    const tunicwild = await db
+        .select()
+        .from(Tunicwild)
+        .where(eq(Tunicwild.id, tunicwildInfo.id))
+        .get();
+
+    if (tunicwild == null) {
+        throw new Error("Missing daily tunicwild in database");
+    }
+
+    const tunicwildsSession = context.locals.session.data.tunicwilds?.[tunicwildDateString] ?? {
+        guesses: [],
+        result: null,
+    };
+    const responseBody: {
+        fourFourFiveEnabled: boolean;
+        session: Required<SessionData>["tunicwilds"][string];
+        tunicwild: Partial<InferSelectModel<typeof Tunicwild>> & { audioUrl: string };
+    } = {
+        fourFourFiveEnabled: context.locals.session.data.memberDiscord != null,
+        session: tunicwildsSession,
+        tunicwild: {
+            audioUrl: `/tunicwilds-rendered/${tunicwildInfo.audioFilenames[
+                tunicwildsSession.result != null
+                    ? tunicwildInfo.audioFilenames.length - 1
+                    : tunicwildsSession.guesses.length
+            ]}`,
+        },
+    };
+
+    if (tunicwildsSession.result != null) {
+        Object.assign(responseBody.tunicwild, tunicwild);
+        delete responseBody.tunicwild.memberDiscord;
+    } else {
+        const guessCount = tunicwildsSession.guesses.length;
+
+        if (guessCount >= 2) {
+            responseBody.tunicwild.releaseDate = tunicwild.releaseDate;
+        }
+
+        if (guessCount >= 4) {
+            responseBody.tunicwild.game = tunicwild.game;
+        }
+    }
+
+    return jsonResponse(responseBody);
+};
+
+export const POST: APIRoute = async (context) => {
+    const params: Partial<Record<keyof any, unknown>> = await context.request.json();
+
+    if (
+        typeof params.timestamp !== "number" ||
+        (params.guess != null && typeof params.guess !== "number")
+    ) {
+        return jsonError("Invalid body");
+    }
+
+    const date = new Date(params.timestamp);
+
+    if (Number.isNaN(date.getTime())) {
+        return jsonError("Invalid timestamp");
+    }
+
+    const dailyInfo: DailyInfo = JSON.parse(await readFile(process.env.TUNICWILDS_DAILY_FILE!, "utf8"));
+    const tunicwildDateString = date.toISOString().slice(0, 10);
+    const tunicwildId = dailyInfo.active.find((info) => info.date === tunicwildDateString)?.id;
+
+    if (tunicwildId == null) {
+        return jsonError("Invalid date. Check if your system clock is set correctly");
+    }
+
+    let tunicwildsSession = context.locals.session.data.tunicwilds?.[tunicwildDateString];
+
+    if (tunicwildsSession == null) {
+        context.locals.session.data.tunicwilds ??= {};
+        tunicwildsSession = context.locals.session.data.tunicwilds[tunicwildDateString] = {
+            guesses: [],
+            result: null,
+        };
+    }
+
+    if (tunicwildsSession.result != null || tunicwildsSession.guesses.length >= 6) {
+        return jsonError("Tunicwild has already been completed");
+    }
+
+    if (params.guess == null) {
+        tunicwildsSession.guesses.push(null);
+    } else {
+        const tunicwild = await db
+            .select()
+            .from(Tunicwild)
+            .where(eq(Tunicwild.id, tunicwildId))
+            .get();
+
+        if (tunicwild == null) {
+            throw new Error("Missing daily tunicwild in database");
+        }
+
+        const guessedTunicwild = await db
+            .select()
+            .from(Tunicwild)
+            .where(eq(Tunicwild.id, params.guess))
+            .get();
+
+        if (guessedTunicwild == null) {
+            return jsonError("Invalid guess");
+        }
+
+        tunicwildsSession.guesses.push({
+            id: params.guess,
+            result: guessedTunicwild.id === tunicwild.id
+                ? "correct"
+                : guessedTunicwild.game === tunicwild.game
+                    ? "correctGame"
+                    : guessedTunicwild.title.toLowerCase() === tunicwild.title.toLowerCase()
+                        ? "correctTitle"
+                        : "incorrect",
+        });
+    }
+
+    if (params.guess === tunicwildId) {
+        tunicwildsSession.result = true;
+    } else if (tunicwildsSession.guesses.length >= 6) {
+        tunicwildsSession.result = false;
+    }
+
+    // TODO delete older games from session
+
+    const url = new URL(context.url);
+    url.searchParams.set("timestamp", params.timestamp.toString());
+
+    return context.redirect(url.toString(), 302);
+};
diff --git a/src/server/session.ts b/src/server/session.ts
index 32aada1..2768358 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -14,10 +14,6 @@ declare global {
     }
 }
 
-export interface SessionData {
-    memberDiscord?: string;
-}
-
 const cookieName = "latex_session";
 const maxAgeMs = 1000 * 60 * 60 * 24 * 30;