diff --git a/CMakeLists.txt b/CMakeLists.txt
index a5c7ec8..766e8e2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -162,7 +162,7 @@ if(RETRO_RUNTIME_TOOLS)
     # --version: what release packaging and hosts read back from the binary.
     add_test(NAME runner_version COMMAND retro-core-runner --version)
     set_tests_properties(runner_version PROPERTIES PASS_REGULAR_EXPRESSION
-        "version ${RETRO_RUNTIME_VERSION}\ncommit [^\n]+\nlink_protocol [0-9]+\\.[0-9]+\n.*gl [01]\ngame_package 1\n")
+        "version ${RETRO_RUNTIME_VERSION}\ncommit [^\n]+\nlink_protocol [0-9]+\\.[0-9]+\n.*gl [01]\ngame_package 1\ndescribe 1\n")
     # Link: the same, driven through retro_corelink the way a host does.
     add_test(NAME link_fake_core
         COMMAND retro-core-link-test --runner $<TARGET_FILE:retro-core-runner>
@@ -174,7 +174,7 @@ if(RETRO_RUNTIME_TOOLS)
     # probe_runner: what a host reads to choose and verify a runner.
     add_test(NAME runner_probe COMMAND retro-core-link-test --probe $<TARGET_FILE:retro-core-runner>)
     set_tests_properties(runner_probe PROPERTIES PASS_REGULAR_EXPRESSION
-        "probe: version ${RETRO_RUNTIME_VERSION}, link [0-9]+\\.[0-9]+, rcore ABI [0-9]+, compatible, game_package 1")
+        "probe: version ${RETRO_RUNTIME_VERSION}, link [0-9]+\\.[0-9]+, rcore ABI [0-9]+, compatible, game_package 1, describe 1")
     # A crash mid-session: the runner dies at frame 5 with no unload. The hub
     # must see it end and still write the save as frames 1-4 left it -- the
     # save memory is the hub's (docs/CORE_LINK.md).
@@ -221,4 +221,17 @@ if(RETRO_RUNTIME_TOOLS)
                     -DOUT=${CMAKE_CURRENT_BINARY_DIR}/test-package-${_case}
                     -P ${CMAKE_CURRENT_SOURCE_DIR}/tests/package_test.cmake)
     endforeach()
+    # --describe: the fake cores' declarations as TAB records, without --rom;
+    # and the refusals (--package for a plain core, a core that is not there).
+    foreach(_case plain package package_none unwanted no_core)
+        add_test(NAME runner_describe_${_case}
+            COMMAND ${CMAKE_COMMAND}
+                    "-DEMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
+                    -DCASE=${_case}
+                    -DRUNNER=$<TARGET_FILE:retro-core-runner>
+                    -DPKG_CORE=$<TARGET_FILE:rcore_fake_pkg_core>
+                    -DPLAIN_CORE=$<TARGET_FILE:rcore_fake_core>
+                    -DPACKAGE=${CMAKE_CURRENT_SOURCE_DIR}/tests/fake_package.txt
+                    -P ${CMAKE_CURRENT_SOURCE_DIR}/tests/describe_test.cmake)
+    endforeach()
 endif()
diff --git a/corelink/link_test_main.cpp b/corelink/link_test_main.cpp
index 9186a5a..3c7b41a 100644
--- a/corelink/link_test_main.cpp
+++ b/corelink/link_test_main.cpp
@@ -94,10 +94,11 @@ int main(int argc, char** argv) {
             RunnerVersion v;
             std::string err;
             if (!probe_runner(utf8_path(val()), v, &err)) die(err);
-            std::printf("probe: version %s, link %u.%u, rcore ABI %u, %s, game_package %u\n",
+            std::printf("probe: version %s, link %u.%u, rcore ABI %u, %s, game_package %u, "
+                        "describe %u\n",
                         v.version.c_str(), v.link_major, v.link_minor, v.abi_major,
                         v.compatible() ? "compatible" : "NOT compatible with this host",
-                        v.game_package);
+                        v.game_package, v.describe);
             return 0;
         } else if (a == "--runner") spec.runner = utf8_path(val());
         else if (a == "--core") spec.core = utf8_path(val());
diff --git a/corelink/runner_probe.cpp b/corelink/runner_probe.cpp
index 8a68bb6..ca6df50 100644
--- a/corelink/runner_probe.cpp
+++ b/corelink/runner_probe.cpp
@@ -67,6 +67,9 @@ bool probe_runner(const fs::path& runner, RunnerVersion& out, std::string* error
     if (fields.count("game_package") && !num("game_package", v.game_package)) {
         return fail("--version printed an unreadable game_package line");
     }
+    if (fields.count("describe") && !num("describe", v.describe)) {
+        return fail("--version printed an unreadable describe line");
+    }
     const std::string link = fields["link_protocol"];
     const auto dot = link.find('.');
     bool ok = !v.version.empty() && dot != std::string::npos && num("rcore_abi_major", v.abi_major) &&
diff --git a/corelink/runner_probe.hpp b/corelink/runner_probe.hpp
index 87acf33..6e6507a 100644
--- a/corelink/runner_probe.hpp
+++ b/corelink/runner_probe.hpp
@@ -22,6 +22,9 @@ struct RunnerVersion {
     // 1 when the runner takes --package (GAME_PACKAGE cores); 0 for a runner
     // from before it did, which prints no game_package line.
     std::uint32_t game_package = 0;
+    // 1 when the runner answers --describe (a core's declared options and
+    // inputs, no ROM; docs/CORE_RUNNER.md); 0 for a runner from before it.
+    std::uint32_t describe = 0;
     // Whether this host can drive it: the link major and the rcore ABI major
     // are this host's own.
     bool compatible() const {
diff --git a/docs/CORE_LINK.md b/docs/CORE_LINK.md
index 4e03963..9c33ec5 100644
--- a/docs/CORE_LINK.md
+++ b/docs/CORE_LINK.md
@@ -86,6 +86,8 @@ hub                                    runner
   hub that needs it as data hashes the file it passed. `retro-core-link-test
   --package` drives it, and `probe_runner` reads `game_package` from
   `--version` (`RunnerVersion::game_package`, 0 for a runner from before it).
+  It reads `describe` the same way (`RunnerVersion::describe`): whether the
+  runner answers `--describe`, which is not a link session (`CORE_RUNNER.md`).
 - **Input rides inside each Grant**, so the contract's "identical within one
   frame" holds by construction.
 - **Savestates (1.1) are taken between frames.** The hub sends `SaveState` or
diff --git a/docs/CORE_RUNNER.md b/docs/CORE_RUNNER.md
index 441aeee..251b1b2 100644
--- a/docs/CORE_RUNNER.md
+++ b/docs/CORE_RUNNER.md
@@ -67,9 +67,14 @@ This page covers what exists and how it is checked.
      write them, and goes to the core unchecked as before. Headless prints
      `state: loaded <path> (envelope|bare, N bytes)`.
 
+5. **Describes a core** (`--describe`, 2026-09-26) for a host building a
+   settings page: `--describe --core <library> [--package <library>]`, no
+   `--rom`. See "--describe" below.
+
 `--version` prints the release version, commit, link protocol and rcore ABI
-compiled in, whether `--gl` is available, and `game_package 1` (this runner
-takes `--package`), and exits 0 (`RELEASES.md`).
+compiled in, whether `--gl` is available, `game_package 1` (this runner
+takes `--package`) and `describe 1` (this runner answers `--describe`), and
+exits 0 (`RELEASES.md`).
 
 Exit codes:
 
@@ -80,6 +85,48 @@ Exit codes:
 | 2 | refused before the core ran: arguments, load, ABI, manifest or game package |
 | 3 | the core broke the contract: an undeclared option key |
 
+## `--describe`
+
+What a core declares, printed without a ROM and without a session. The runner
+loads the library and checks its sidecar exactly as for a run (a refusal is
+exit 2, message on stderr, nothing on stdout). It then reads `options()` and
+`input_descriptors()`, which `rcore.h` declares "before load" and which the
+session already reads before `init`. It calls neither `init` nor `load`, and
+it does not refuse an `OWNS_LOOP` core, because nothing is driven.
+
+`--package` gets the same refusals as for a run (a core without
+`game_package` refuses one; it must be a readable file). A `game_package`
+core is described without one too: a package reaches a core only through
+`load()`, so it cannot change what is declared before it.
+
+Stdout is UTF-8, one record per line, fields separated by one TAB, and
+nothing else:
+
+```
+describe	1
+core	<core_id>	<core_version>	<platforms>
+option	<key>	<type>	<flags>	<has_default>	<default>	<int_min>	<int_max>	<label>	<description>
+value	<key>	<one enum value>
+input	<button>	<axis>	<axis_direction>	<label>
+```
+
+- Every field escapes `\` as `\\`, TAB as `\t`, LF as `\n` and CR as `\r`, so a
+  record is always one line. A NULL C string is the empty field.
+- `<type>` is `enum`, `bool`, `int` or `string`; a type this runner does not
+  know prints as its number.
+- `<flags>` is a comma-separated subset of `restart,netplay,developer`, in
+  that order, or `-` for none.
+- `<has_default>` is `1` when `default_value` is non-NULL, else `0` (unset:
+  the core applies its own default); `<default>` is the value or empty.
+- `<int_min>` and `<int_max>` are decimal int64, printed for every type.
+- `value` records follow their enum option, one per entry of its
+  NULL-terminated `values`, in declared order.
+- `<button>` is the `RCORE_PAD_*` bit in decimal (0 for an axis),
+  `<axis>` is as declared (`RCORE_AXIS_*` + 1, or 0), and `<axis_direction>`
+  is a signed decimal.
+- Options and inputs appear in declared order. `describe 1` is the format's
+  version.
+
 ## How it is checked
 
 Because the command line matches, n64lle's own gate grades this runner with no
@@ -117,6 +164,14 @@ package's hash logged, and each refusal above exits 2
 (`runner_package_*`, `tests/package_test.cmake`). No real generic core has
 run through it yet.
 
+`--describe` (2026-09-26) is checked by ctest on both fake cores, whose
+options and inputs cover every type and flag, NULL defaults and
+descriptions, and a TAB, LF, CR and backslash inside a field. Each case
+compares stdout byte for byte (`runner_describe_*`,
+`tests/describe_test.cmake`). **Run by hand 2026-09-26** on n64lle's generic
+`n64lle_core.so` (0.374.0, sidecar beside it): exit 0, 76 options, 16 enum
+values and 16 inputs, every record with its field count.
+
 ## Not built yet
 
 - **Netplay** (rev 4: the runner binds recomp-net's `rb_driver`).
diff --git a/docs/RELEASES.md b/docs/RELEASES.md
index a169724..2eab33e 100644
--- a/docs/RELEASES.md
+++ b/docs/RELEASES.md
@@ -114,6 +114,7 @@ rcore_abi_major 0
 rcore_draft_revision 5
 gl 1
 game_package 1
+describe 1
 ```
 
 A build outside a release says `version dev`. `game_package 1` (2026-09-26)
@@ -122,6 +123,11 @@ runner from before it prints no such line, and `probe_runner` reports 0. It
 is not yet a field of `runtime-manifest.json`; a host checks it on the
 extracted binary (step 7).
 
+`describe 1` (2026-09-26) means the runner answers `--describe` with format
+version 1 (`CORE_RUNNER.md`, "--describe"); a runner from before it prints
+no such line, and `probe_runner` reports 0. Like `game_package`, it is read
+from the binary, not the manifest.
+
 ## The update rule, for a host
 
 1. Fetch the manifest. If `schema` is not one the host knows, keep the
diff --git a/runner/runner_main.cpp b/runner/runner_main.cpp
index 9b6719c..47960f2 100644
--- a/runner/runner_main.cpp
+++ b/runner/runner_main.cpp
@@ -20,8 +20,22 @@
 //
 // --version prints what this binary is, one "key value" per line: the release
 // version and commit compiled in, the link protocol and rcore ABI it speaks,
-// whether --gl is available, and whether it takes --package (game_package).
-// Release packaging and hosts read it back.
+// whether --gl is available, whether it takes --package (game_package), and
+// whether it answers --describe (describe). Release packaging and hosts read
+// it back.
+//
+// --describe --core <library> [--package <library>]: what the core DECLARES,
+// for a host building a settings page -- no ROM, no init, no session. The
+// library is loaded and its sidecar checked as for a run, then options() and
+// input_descriptors() are read (both "before load", rcore.h) and printed as
+// TAB-separated records, one per line (docs/CORE_RUNNER.md, "--describe"):
+//   describe 1
+//   core     <core_id> <core_version> <platforms>
+//   option   <key> <type> <flags> <has_default> <default> <int_min> <int_max>
+//            <label> <description>
+//   value    <key> <one enum value>        (after its option, in declared order)
+//   input    <button> <axis> <axis_direction> <label>
+// Nothing else goes to stdout. A refusal is exit 2, as for a run.
 //
 // --package <library>: a GAME_PACKAGE core's generated-code package, passed
 // as rcore_load_params.package_path. Required for such a core, refused for
@@ -41,6 +55,7 @@
 #include "state_keeper.hpp"
 #include "transport.hpp"
 
+#include <cinttypes>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -55,6 +70,10 @@
 #if defined(RETRO_RUNNER_HAVE_SDL3)
 #  include <SDL3/SDL.h>
 #endif
+#if defined(_WIN32)
+#  include <fcntl.h>
+#  include <io.h>
+#endif
 
 using namespace retro::runner;
 
@@ -241,12 +260,78 @@ void print_version() {
                 "rcore_abi_major %u\n"
                 "rcore_draft_revision %u\n"
                 "gl %d\n"
-                "game_package 1\n",
+                "game_package 1\n"
+                "describe 1\n",
                 RETRO_RUNTIME_VERSION, RETRO_RUNTIME_VERSION, RETRO_RUNTIME_COMMIT,
                 retro::corelink::kProtocolMajor, retro::corelink::kProtocolMinor,
                 RCORE_ABI_MAJOR, RCORE_DRAFT_REVISION, gl);
 }
 
+// One --describe field: \ TAB LF CR escaped, so a record is one line; a NULL
+// C string is the empty field.
+std::string describe_field(const char* s) {
+    std::string out;
+    for (; s && *s; ++s) {
+        switch (*s) {
+        case '\\': out += "\\\\"; break;
+        case '\t': out += "\\t"; break;
+        case '\n': out += "\\n"; break;
+        case '\r': out += "\\r"; break;
+        default: out += *s;
+        }
+    }
+    return out;
+}
+
+// --describe: print what the core declares, exactly as declared, and nothing
+// the runner would have to make up. Neither init nor load is called.
+void print_description(const LoadedCore& core) {
+#if defined(_WIN32)
+    _setmode(_fileno(stdout), _O_BINARY); // records end in LF on every OS
+#endif
+    const rcore_core_info& info = *core.info;
+    std::string out = "describe\t1\n";
+    out += "core\t" + describe_field(info.core_id) + '\t' + describe_field(info.core_version) +
+           '\t' + describe_field(info.platforms) + '\n';
+    std::uint32_t n = 0;
+    const rcore_option* opts = core.api->options ? core.api->options(&n) : nullptr;
+    for (std::uint32_t i = 0; opts && i < n; ++i) {
+        const rcore_option& o = opts[i];
+        const std::string key = describe_field(o.key);
+        std::string type = o.type == RCORE_OPT_ENUM     ? "enum"
+                           : o.type == RCORE_OPT_BOOL   ? "bool"
+                           : o.type == RCORE_OPT_INT    ? "int"
+                           : o.type == RCORE_OPT_STRING ? "string"
+                                                        : std::to_string(o.type);
+        std::string flags;
+        if (o.flags & RCORE_OPT_FLAG_RESTART) flags += ",restart";
+        if (o.flags & RCORE_OPT_FLAG_NETPLAY) flags += ",netplay";
+        if (o.flags & RCORE_OPT_FLAG_DEVELOPER) flags += ",developer";
+        flags = flags.empty() ? "-" : flags.substr(1);
+        char range[48];
+        std::snprintf(range, sizeof range, "%" PRId64 "\t%" PRId64, o.int_min, o.int_max);
+        out += "option\t" + key + '\t' + type + '\t' + flags + '\t' +
+               (o.default_value ? "1" : "0") + '\t' + describe_field(o.default_value) + '\t' +
+               range + '\t' + describe_field(o.label) + '\t' + describe_field(o.description) +
+               '\n';
+        if (o.type == RCORE_OPT_ENUM && o.values) {
+            for (const char* const* v = o.values; *v; ++v) {
+                out += "value\t" + key + '\t' + describe_field(*v) + '\n';
+            }
+        }
+    }
+    n = 0;
+    const rcore_input_descriptor* descs =
+        core.api->input_descriptors ? core.api->input_descriptors(&n) : nullptr;
+    for (std::uint32_t i = 0; descs && i < n; ++i) {
+        const rcore_input_descriptor& d = descs[i];
+        out += "input\t" + std::to_string(d.button) + '\t' + std::to_string(d.axis) + '\t' +
+               std::to_string(d.axis_direction) + '\t' + describe_field(d.label) + '\n';
+    }
+    std::fwrite(out.data(), 1, out.size(), stdout);
+    std::fflush(stdout);
+}
+
 } // namespace
 
 int main(int argc, char** argv) {
@@ -259,6 +344,7 @@ int main(int argc, char** argv) {
     std::optional<fs::path> load_state, tpak_save, tpak_rtc;
     std::string tpak_rom, link_handles;
     bool gl = false, strict = false, seat0 = true, list_options = false, link = false;
+    bool describe = false;
     std::optional<std::uint64_t> replay_at;
     std::map<std::string, std::string> overrides;
     std::vector<std::pair<std::uint64_t, std::uint32_t>> script;
@@ -294,6 +380,7 @@ int main(int argc, char** argv) {
         else if (a == "--strict") strict = true;
         else if (a == "--no-seats") seat0 = false;
         else if (a == "--list-options") list_options = true;
+        else if (a == "--describe") describe = true;
         else if (a == "--replay-at") replay_at = num(val());
         else if (a == "--opt") {
             const std::string kv = val();
@@ -319,20 +406,24 @@ int main(int argc, char** argv) {
         }
     }
     if (core_path.empty()) die("--core <library> is required");
-    if (rom.empty()) die("--rom <image> is required");
+    if (rom.empty() && !describe) die("--rom <image> is required");
     std::error_code ec;
-    fs::create_directories(out, ec);
+    if (!describe) fs::create_directories(out, ec);
 
     // ---- load: hash the file that is loaded, then the one symbol ---------
     LoadedCore core;
     std::string err;
     if (!load_core(retro::corelink::utf8_path(core_path), core, &err)) die(err);
     const rcore_core_info& info = *core.info;
-    std::printf("core: %s %s platforms=%s capabilities=0x%llx state_compat_id=%s\n",
-                info.core_id, info.core_version, info.platforms,
-                static_cast<unsigned long long>(info.capabilities),
-                info.state_compat_id ? info.state_compat_id : "NULL");
-    std::printf("identity: sha256 %s\n", core.sha256.c_str());
+    // --describe's stdout is its records alone: the lines a run prints about
+    // the core and its sidecar are left out, the checks are not.
+    if (!describe) {
+        std::printf("core: %s %s platforms=%s capabilities=0x%llx state_compat_id=%s\n",
+                    info.core_id, info.core_version, info.platforms,
+                    static_cast<unsigned long long>(info.capabilities),
+                    info.state_compat_id ? info.state_compat_id : "NULL");
+        std::printf("identity: sha256 %s\n", core.sha256.c_str());
+    }
 
     // ---- the sidecar must agree with the library, field for field --------
     CoreManifest manifest;
@@ -344,17 +435,24 @@ int main(int argc, char** argv) {
         for (const auto& d : diffs) std::fprintf(stderr, "  %s\n", d.c_str());
         return 2;
     }
-    std::printf("manifest: %s agrees (draft revision %ld; runner %u)%s\n",
-                manifest.path.filename().string().c_str(), manifest.draft_revision,
-                RCORE_DRAFT_REVISION, manifest.engine_dirty ? "; engine DIRTY" : "");
-    if (!(info.capabilities & RCORE_CAP_RUN_FRAME) || !core.api->run_frame) {
+    if (!describe) {
+        std::printf("manifest: %s agrees (draft revision %ld; runner %u)%s\n",
+                    manifest.path.filename().string().c_str(), manifest.draft_revision,
+                    RCORE_DRAFT_REVISION, manifest.engine_dirty ? "; engine DIRTY" : "");
+    }
+    // Describing drives nothing, so an OWNS_LOOP core's declarations are
+    // readable too.
+    if (!describe && (!(info.capabilities & RCORE_CAP_RUN_FRAME) || !core.api->run_frame)) {
         die("this runner drives RUN_FRAME cores only; the core declares none");
     }
 
     // ---- the game package: required by a GAME_PACKAGE core, refused otherwise
+    // --describe keeps the refusals but not the requirement: the declarations
+    // are the core's, read before load, and a package reaches a core only
+    // through load(). So a package core describes itself without one.
     const bool wants_package = (info.capabilities & RCORE_CAP_GAME_PACKAGE) != 0;
     std::string pkg_sha;
-    if (wants_package && package.empty()) {
+    if (wants_package && package.empty() && !describe) {
         die(std::string("core '") + info.core_id +
             "' declares game_package: --package <library> (the title's generated code) is required");
     }
@@ -362,7 +460,7 @@ int main(int argc, char** argv) {
         die(std::string("--package: core '") + info.core_id +
             "' does not declare game_package, so it takes no package");
     }
-    if (wants_package) {
+    if (!package.empty()) {
         // The core opens the package itself; this names the file as it stood
         // when the runner looked. A package is identity (docs/CORE_ABI.md,
         // "Netplay"): its hash is logged beside the core's.
@@ -371,7 +469,12 @@ int main(int argc, char** argv) {
         if (!fs::is_regular_file(pkg, pec)) die("--package " + package + ": not a file");
         pkg_sha = file_sha256_hex(pkg);
         if (pkg_sha.empty()) die("--package " + package + ": unreadable");
-        std::printf("package: %s sha256 %s\n", package.c_str(), pkg_sha.c_str());
+        if (!describe) std::printf("package: %s sha256 %s\n", package.c_str(), pkg_sha.c_str());
+    }
+
+    if (describe) {
+        print_description(core);
+        return 0;
     }
 
     // ---- link mode: the hub drives the session -----------------------------
diff --git a/tests/describe_test.cmake b/tests/describe_test.cmake
new file mode 100644
index 0000000..d365e17
--- /dev/null
+++ b/tests/describe_test.cmake
@@ -0,0 +1,85 @@
+# --describe (docs/CORE_RUNNER.md, "--describe"): what a core declares, as TAB
+# records, with no ROM and no session. The fake cores declare the options and
+# inputs below (tests/rcore_fake_core.c); stdout must be exactly these lines.
+# CASE picks the scenario:
+#
+#   plain          fake_core, no --rom: the records, byte for byte
+#   package        fake_pkg_core + --package: the same records, its own id
+#   package_none   fake_pkg_core without --package: still described
+#   unwanted       fake_core given --package: refused, exit 2
+#   no_core        a core that does not exist: refused, exit 2, stdout empty
+#
+# EMULATOR is CMAKE_CROSSCOMPILING_EMULATOR (wine, for a MinGW build), if any.
+string(ASCII 9 TAB)
+
+function(run)
+    execute_process(COMMAND ${EMULATOR} ${ARGN}
+                    RESULT_VARIABLE rc OUTPUT_VARIABLE out ERROR_VARIABLE err)
+    message("${out}${err}")
+    set(rc "${rc}" PARENT_SCOPE)
+    set(out "${out}" PARENT_SCOPE)
+    set(err "${err}" PARENT_SCOPE)
+endfunction()
+
+# The expected stdout for core id `id`. <T> is a TAB; everything else is
+# literal, so \n here is a backslash and an n -- the escaped field.
+function(expected id var)
+    set(lines
+        [=[describe<T>1]=]
+        [=[core<T>@ID@<T>1.0<T>test]=]
+        [=[option<T>video.mode<T>enum<T>restart,netplay<T>1<T>fast<T>0<T>0<T>Video mode<T>Line one\nline two\twith a back\\slash]=]
+        [=[value<T>video.mode<T>fast]=]
+        [=[value<T>video.mode<T>accurate]=]
+        [=[value<T>video.mode<T>tab\there]=]
+        [=[option<T>audio.mute<T>bool<T>-<T>1<T>0<T>0<T>0<T>Mute<T>]=]
+        [=[option<T>cpu.overclock<T>int<T>developer<T>0<T><T>-5<T>1000000000000<T>Overclock<T>Percent over stock]=]
+        [=[option<T>debug.trace<T>string<T>restart,netplay,developer<T>0<T><T>0<T>0<T>Trace\rfile<T>]=]
+        [=[input<T>1<T>0<T>0<T>A]=]
+        [=[input<T>0<T>3<T>-1<T>C-Left]=]
+        [=[input<T>0<T>1<T>0<T>Stick]=])
+    string(JOIN "\n" text ${lines})
+    string(REPLACE "<T>" "${TAB}" text "${text}")
+    string(REPLACE "@ID@" "${id}" text "${text}")
+    set(${var} "${text}\n" PARENT_SCOPE)
+endfunction()
+
+function(expect_described id)
+    if(NOT rc EQUAL 0)
+        message(FATAL_ERROR "--describe exited ${rc}")
+    endif()
+    expected("${id}" want)
+    if(NOT out STREQUAL want)
+        message(FATAL_ERROR "--describe printed:\n${out}\nexpected:\n${want}")
+    endif()
+endfunction()
+
+function(expect_refused pattern)
+    if(NOT rc EQUAL 2)
+        message(FATAL_ERROR "expected a refusal (exit 2), got exit ${rc}")
+    endif()
+    if(NOT out STREQUAL "")
+        message(FATAL_ERROR "a refusal printed to stdout:\n${out}")
+    endif()
+    if(NOT err MATCHES "${pattern}")
+        message(FATAL_ERROR "the refusal does not say '${pattern}'")
+    endif()
+endfunction()
+
+if(CASE STREQUAL "plain")
+    run("${RUNNER}" --describe --core "${PLAIN_CORE}")
+    expect_described(fake)
+elseif(CASE STREQUAL "package")
+    run("${RUNNER}" --describe --core "${PKG_CORE}" --package "${PACKAGE}")
+    expect_described(fake_pkg)
+elseif(CASE STREQUAL "package_none")
+    run("${RUNNER}" --describe --core "${PKG_CORE}")
+    expect_described(fake_pkg)
+elseif(CASE STREQUAL "unwanted")
+    run("${RUNNER}" --describe --core "${PLAIN_CORE}" --package "${PACKAGE}")
+    expect_refused("does not declare game_package, so it takes no package")
+elseif(CASE STREQUAL "no_core")
+    run("${RUNNER}" --describe --core "${PLAIN_CORE}.does-not-exist")
+    expect_refused("retro-core-runner: ")
+else()
+    message(FATAL_ERROR "unknown CASE '${CASE}'")
+endif()
diff --git a/tests/rcore_fake_core.c b/tests/rcore_fake_core.c
index 555c891..833eca2 100644
--- a/tests/rcore_fake_core.c
+++ b/tests/rcore_fake_core.c
@@ -18,6 +18,11 @@
  * outright, with no unload: a crash, as far as the host can tell. The host
  * link must still write the save as frames 1..N-1 left it.
  *
+ * It declares four options and three input descriptors that it never reads:
+ * they are there for --describe (tests/describe_test.cmake), so every option
+ * type, every flag, a NULL default and description, and a TAB, LF, CR and
+ * backslash inside a field are all exercised.
+ *
  * Built with FAKE_GAME_PACKAGE it is fake_pkg_core: core id "fake_pkg", it
  * also declares GAME_PACKAGE, and load() requires package_path to name a
  * readable file whose first line is FAKE_PACKAGE_MAGIC (tests/fake_package.txt),
@@ -64,8 +69,34 @@ static const rcore_core_info k_info = {
     FAKE_ID, "1.0", "test", FAKE_CAPS, NULL,
 };
 
-static const rcore_option* opts(uint32_t* count) { *count = 0; return NULL; }
-static const rcore_input_descriptor* descs(uint32_t* count) { *count = 0; return NULL; }
+static const char* const k_mode_values[] = {"fast", "accurate", "tab\there", NULL};
+
+static const rcore_option k_options[] = {
+    {sizeof(rcore_option), RCORE_OPT_ENUM, RCORE_OPT_FLAG_RESTART | RCORE_OPT_FLAG_NETPLAY, 0,
+     "video.mode", "Video mode", "Line one\nline two\twith a back\\slash", "fast",
+     k_mode_values, 0, 0},
+    {sizeof(rcore_option), RCORE_OPT_BOOL, 0, 0, "audio.mute", "Mute", NULL, "0", NULL, 0, 0},
+    {sizeof(rcore_option), RCORE_OPT_INT, RCORE_OPT_FLAG_DEVELOPER, 0, "cpu.overclock",
+     "Overclock", "Percent over stock", NULL, NULL, -5, 1000000000000LL},
+    {sizeof(rcore_option), RCORE_OPT_STRING,
+     RCORE_OPT_FLAG_RESTART | RCORE_OPT_FLAG_NETPLAY | RCORE_OPT_FLAG_DEVELOPER, 0,
+     "debug.trace", "Trace\rfile", NULL, NULL, NULL, 0, 0},
+};
+
+static const rcore_input_descriptor k_inputs[] = {
+    {sizeof(rcore_input_descriptor), RCORE_PAD_SOUTH, 0, 0, "A"},
+    {sizeof(rcore_input_descriptor), 0, RCORE_AXIS_RX + 1, -1, "C-Left"},
+    {sizeof(rcore_input_descriptor), 0, RCORE_AXIS_LX + 1, 0, "Stick"},
+};
+
+static const rcore_option* opts(uint32_t* count) {
+    *count = sizeof k_options / sizeof k_options[0];
+    return k_options;
+}
+static const rcore_input_descriptor* descs(uint32_t* count) {
+    *count = sizeof k_inputs / sizeof k_inputs[0];
+    return k_inputs;
+}
 
 static rcore_result init(const rcore_host_api* host, const rcore_init_params* params) {
     (void)params;