diff --git a/.gitignore b/.gitignore
--- a/.gitignore
+++ b/.gitignore
@@ -8,6 +8,7 @@
 src/bitcoin-cli
 src/bitcoin-seeder
 src/bitcoin-tx
+src/bitcoin-chainstate
 src/bitcoin-wallet
 src/test/test_bitcoin
 src/test/test_bitcoin_fuzzy
diff --git a/contrib/teamcity/build-configurations.yml b/contrib/teamcity/build-configurations.yml
--- a/contrib/teamcity/build-configurations.yml
+++ b/contrib/teamcity/build-configurations.yml
@@ -317,6 +317,7 @@
       toolchain: Linux64
     cmake_flags:
       - '-DBUILD_BITCOIN_CHRONIK=ON'
+      - '-DBUILD_BITCOIN_CHAINSTATE=ON'
     templates:
       - check+secp256k1
     timeout: 3600
@@ -328,6 +329,7 @@
       emulator: qemu-aarch64-static
     cmake_flags:
       - '-DBUILD_BITCOIN_CHRONIK=ON'
+      - '-DBUILD_BITCOIN_CHAINSTATE=ON'
       # The ZMQ functional test will fail with qemu (due to a qemu limitation),
       # so disable it to avoid the failure.
       # Extracted from stderr:
@@ -359,6 +361,7 @@
       emulator: qemu-arm-static
     cmake_flags:
       - '-DBUILD_BITCOIN_CHRONIK=ON'
+      - '-DBUILD_BITCOIN_CHAINSTATE=ON'
       # The ZMQ functional test will fail with qemu (due to a qemu limitation),
       # so disable it to avoid the failure.
       # Extracted from stderr:
@@ -394,6 +397,8 @@
     timeout: 1200
 
   build-master:
+    cmake_flags:
+      - '-DBUILD_BITCOIN_CHAINSTATE=ON'
     Werror: true
     targets:
       - - all
@@ -412,8 +417,9 @@
     cross_build:
       static_depends: osx
       toolchain: OSX
+    cmake_flags:
+      - '-DBUILD_BITCOIN_CHAINSTATE=ON'
     # Uncomment to build Chronik once the cxx crate is working for OSX
-    # cmake_flags:
     #  - '-DBUILD_BITCOIN_CHRONIK=ON'
     targets:
       - - all
@@ -492,6 +498,7 @@
       toolchain: Win64
     cmake_flags:
       - '-DBUILD_BITCOIN_CHRONIK=ON'
+      - '-DBUILD_BITCOIN_CHAINSTATE=ON'
       - "-DBUILD_BITCOIN_SEEDER=OFF"
       - "-DCPACK_STRIP_FILES=ON"
       - "-DUSE_JEMALLOC=OFF"
@@ -551,6 +558,7 @@
     Werror: true
     cmake_flags:
       - '-DBUILD_BITCOIN_WALLET=OFF'
+      - '-DBUILD_BITCOIN_CHAINSTATE=ON'
     targets:
       - - all
         - install
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -16,6 +16,7 @@
 option(BUILD_BITCOIN_QT "Build bitcoin-qt" ON)
 option(BUILD_BITCOIN_SEEDER "Build bitcoin-seeder" ON)
 option(BUILD_LIBBITCOINCONSENSUS "Build the bitcoinconsenus shared library" ON)
+option(BUILD_BITCOIN_CHAINSTATE "Build bitcoin-chainstate" OFF)
 option(ENABLE_BIP70 "Enable BIP70 (payment protocol) support in GUI" ON)
 option(ENABLE_HARDENING "Harden the executables" ON)
 option(ENABLE_REDUCE_EXPORTS "Reduce the amount of exported symbols" OFF)
@@ -816,6 +817,155 @@
 	install_manpages(bitcoin-tx)
 endif()
 
+# bitcoin-chainstate
+if(BUILD_BITCOIN_CHAINSTATE)
+	add_executable(bitcoin-chainstate
+		bitcoin-chainstate.cpp
+
+		# bitcoin-chainstate dependencies
+		# The goal is for this list to grow shorter as more and more modules
+		# of the codebase are decoupled from the consensus engine.
+		arith_uint256.cpp
+		blockfileinfo.cpp
+		blockfilter.cpp
+		blockindex.cpp
+		bloom.cpp
+		chain.cpp
+		chainparamsbase.cpp
+		chainparams.cpp
+		checkpoints.cpp
+		clientversion.cpp
+		coins.cpp
+		compat/glibcxx_sanity.cpp
+		compressor.cpp
+		config.cpp
+		consensus/activation.cpp
+		consensus/amount.cpp
+		consensus/merkle.cpp
+		consensus/tx_check.cpp
+		consensus/tx_verify.cpp
+		core_read.cpp
+		dbwrapper.cpp
+		deploymentstatus.cpp
+		eventloop.cpp
+		feerate.cpp
+		flatfile.cpp
+		fs.cpp
+		hash.cpp
+		index/base.cpp
+		index/blockfilterindex.cpp
+		index/coinstatsindex.cpp
+		init/common.cpp
+		key.cpp
+		logging.cpp
+		netaddress.cpp
+		networks/abc/chainparamsconstants.cpp
+		networks/abc/checkpoints.cpp
+		node/blockstorage.cpp
+		node/chainstate.cpp
+		node/coinstats.cpp
+		node/ui_interface.cpp
+		node/utxo_snapshot.cpp
+		policy/fees.cpp
+		policy/packages.cpp
+		policy/policy.cpp
+		policy/settings.cpp
+		pow/aserti32d.cpp
+		pow/daa.cpp
+		pow/eda.cpp
+		pow/pow.cpp
+		primitives/block.cpp
+		primitives/transaction.cpp
+		pubkey.cpp
+		random.cpp
+		randomenv.cpp
+		rcu.cpp
+		scheduler.cpp
+		script/bitfield.cpp
+		script/interpreter.cpp
+		script/script.cpp
+		script/scriptcache.cpp
+		script/script_error.cpp
+		script/sigcache.cpp
+		script/sigencoding.cpp
+		script/standard.cpp
+		shutdown.cpp
+		support/cleanse.cpp
+		support/lockedpool.cpp
+		sync.cpp
+		threadinterrupt.cpp
+		timedata.cpp
+		txdb.cpp
+		txmempool.cpp
+		uint256.cpp
+		util/asmap.cpp
+		util/bytevectorhash.cpp
+		util/check.cpp
+		util/getuniquepath.cpp
+		util/hasher.cpp
+		util/moneystr.cpp
+		util/settings.cpp
+		util/strencodings.cpp
+		util/string.cpp
+		util/system.cpp
+		util/thread.cpp
+		util/threadnames.cpp
+		util/time.cpp
+		util/tokenpipe.cpp
+		validation.cpp
+		validationinterface.cpp
+		versionbits.cpp
+		warnings.cpp
+
+		# Bitcoin ABC specific dependencies that will not go away with Core backports
+		addrdb.cpp   # via banman.cpp
+		addrman.cpp  # via net.cpp
+		banman.cpp   # via net.cpp
+		base58.cpp   # via key_io.cpp
+		avalanche/avalanche.cpp
+		avalanche/delegation.cpp
+		avalanche/delegationbuilder.cpp
+		avalanche/peermanager.cpp
+		avalanche/processor.cpp
+		avalanche/proof.cpp
+		avalanche/proofid.cpp
+		avalanche/proofpool.cpp
+		avalanche/voterecord.cpp
+		cashaddr.cpp         # via cashaddrenc.cpp
+		cashaddrenc.cpp      # via key_io.cpp
+		dnsseeds.cpp         # via net.cpp (GetRandomizedDNSSeeds)
+		i2p.cpp              # via net.cpp
+		key_io.cpp           # avalanche/processor.cpp uses DecodeSecret
+		minerfund.cpp        # via policy/block/minerfund.cpp
+		net.cpp              # avalanche uses CConnman
+		netbase.cpp          # via net.cpp
+		net_permissions.cpp  # via net.cpp
+		policy/block/minerfund.cpp
+		policy/block/stakingrewards.cpp
+		protocol.cpp            # avalanche/processor.cpp uses NetMsgType
+		util/error.cpp          # via net_permissions.cpp (ResolveErrMsg)
+		util/readwritefile.cpp  # via i2p.cpp
+		util/sock.cpp           # via net.cpp
+	)
+
+	target_include_directories(bitcoin-chainstate
+		PRIVATE
+			.
+			leveldb/helpers/memenv
+			# To access the config/ and obj/ directories
+			${CMAKE_CURRENT_BINARY_DIR}
+	)
+	target_link_libraries(bitcoin-chainstate crypto univalue secp256k1 leveldb memenv)
+	link_boost_headers_only(bitcoin-chainstate headers)
+
+	generate_windows_version_info(bitcoin-chainstate
+		DESCRIPTION "CLI Datadir information utility (experimental)"
+	)
+
+	add_to_symbols_check(bitcoin-chainstate)
+	add_to_security_check(bitcoin-chainstate)
+endif()
+
 # bitcoind
 add_executable(bitcoind bitcoind.cpp)
 target_link_libraries(bitcoind server)
diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
new file mode 100644
--- /dev/null
+++ b/src/bitcoin-chainstate.cpp
@@ -0,0 +1,285 @@
+// Copyright (c) 2022 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+//
+// The bitcoin-chainstate executable serves to surface the dependencies required
+// by a program wishing to use Bitcoin Core's consensus engine as it is right
+// now.
+//
+// DEVELOPER NOTE: Since this is a "demo-only", experimental, etc. executable,
+//                 it may diverge from Bitcoin Core's coding style.
+//
+// It is part of the libbitcoinkernel project.
+
+#include <chainparams.h>
+#include <config.h>
+#include <consensus/validation.h>
+#include <core_io.h>
+#include <init/common.h>
+#include <node/blockstorage.h>
+#include <node/caches.h>
+#include <node/chainstate.h>
+#include <scheduler.h>
+#include <script/scriptcache.h>
+#include <script/sigcache.h>
+#include <util/system.h>
+#include <util/thread.h>
+#include <validation.h>
+#include <validationinterface.h>
+
+#include <filesystem>
+#include <functional>
+#include <iosfwd>
+
+const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;
+
+int main(int argc, char *argv[]) {
+    // SETUP: Argument parsing and handling
+    if (argc != 2) {
+        std::cerr << "Usage: " << argv[0] << " DATADIR" << std::endl
+                  << "Display DATADIR information, and process hex-encoded "
+                     "blocks on standard input."
+                  << std::endl
+                  << std::endl
+                  << "IMPORTANT: THIS EXECUTABLE IS EXPERIMENTAL, FOR TESTING "
+                     "ONLY, AND EXPECTED TO"
+                  << std::endl
+                  << "           BREAK IN FUTURE VERSIONS. DO NOT USE ON YOUR "
+                     "ACTUAL DATADIR."
+                  << std::endl;
+        return 1;
+    }
+    std::filesystem::path abs_datadir = std::filesystem::absolute(argv[1]);
+    std::filesystem::create_directories(abs_datadir);
+    gArgs.ForceSetArg("-datadir", abs_datadir.string());
+
+    // SETUP: Misc Globals
+    SelectParams(CBaseChainParams::MAIN);
+    const Config &config = GetConfig();
+
+    // ECC_Start, etc.
+    init::SetGlobals();
+
+    // Necessary for CheckInputScripts (eventually called by ProcessNewBlock),
+    // which will try the script cache first and fall back to actually
+    // performing the check with the signature cache.
+    InitSignatureCache();
+    InitScriptExecutionCache();
+
+    // SETUP: Scheduling and Background Signals
+    CScheduler scheduler{};
+    // Start the lightweight task scheduler thread
+    scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler",
+                                             [&] { scheduler.serviceQueue(); });
+
+    // Gather some entropy once per minute.
+    scheduler.scheduleEvery(
+        [] {
+            RandAddPeriodic();
+            return true;
+        },
+        std::chrono::minutes{1});
+
+    GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
+
+    // SETUP: Chainstate
+    ChainstateManager chainman{config};
+
+    node::CacheSizes cache_sizes;
+    cache_sizes.block_tree_db = 2 << 20;
+    cache_sizes.coins_db = 2 << 22;
+    cache_sizes.coins = (450 << 20) - (2 << 20) - (2 << 22);
+    node::ChainstateLoadOptions options;
+    options.check_interrupt = [] { return false; };
+    auto [status, error] = node::LoadChainstate(chainman, cache_sizes, options);
+    if (status != node::ChainstateLoadStatus::SUCCESS) {
+        std::cerr << "Failed to load Chain state from your datadir."
+                  << std::endl;
+        goto epilogue;
+    }
+    std::tie(status, error) =
+        node::VerifyLoadedChainstate(chainman, options, config);
+    if (status != node::ChainstateLoadStatus::SUCCESS) {
+        std::cerr << "Failed to verify loaded Chain state from your datadir."
+                  << std::endl;
+        goto epilogue;
+    }
+
+    for (Chainstate *chainstate :
+         WITH_LOCK(::cs_main, return chainman.GetAll())) {
+        BlockValidationState state;
+        if (!chainstate->ActivateBestChain(config, state, nullptr)) {
+            std::cerr << "Failed to connect best block (" << state.ToString()
+                      << ")" << std::endl;
+            goto epilogue;
+        }
+    }
+
+    // Main program logic starts here
+    std::cout
+        << "Hello! I'm going to print out some information about your datadir."
+        << std::endl;
+    {
+        LOCK(chainman.GetMutex());
+        std::cout << "\t"
+                  << "Path: " << gArgs.GetDataDirNet() << std::endl
+                  << "\t"
+                  << "Reindexing: " << std::boolalpha << node::fReindex.load()
+                  << std::noboolalpha << std::endl
+                  << "\t"
+                  << "Snapshot Active: " << std::boolalpha
+                  << chainman.IsSnapshotActive() << std::noboolalpha
+                  << std::endl
+                  << "\t"
+                  << "Active Height: " << chainman.ActiveHeight() << std::endl
+                  << "\t"
+                  << "Active IBD: " << std::boolalpha
+                  << chainman.ActiveChainstate().IsInitialBlockDownload()
+                  << std::noboolalpha << std::endl;
+        CBlockIndex *tip = chainman.ActiveTip();
+        if (tip) {
+            std::cout << "\t" << tip->ToString() << std::endl;
+        }
+    }
+
+    for (std::string line; std::getline(std::cin, line);) {
+        if (line.empty()) {
+            std::cerr << "Empty line found" << std::endl;
+            break;
+        }
+
+        std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
+        CBlock &block = *blockptr;
+
+        if (!DecodeHexBlk(block, line)) {
+            std::cerr << "Block decode failed" << std::endl;
+            break;
+        }
+
+        if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
+            std::cerr << "Block does not start with a coinbase" << std::endl;
+            break;
+        }
+
+        BlockHash hash = block.GetHash();
+        {
+            LOCK(cs_main);
+            const CBlockIndex *pindex =
+                chainman.m_blockman.LookupBlockIndex(hash);
+            if (pindex) {
+                if (pindex->IsValid(BlockValidity::SCRIPTS)) {
+                    std::cerr << "Duplicate" << std::endl;
+                    break;
+                }
+                if (pindex->nStatus.hasFailed()) {
+                    std::cerr << "Duplicate-invalid" << std::endl;
+                    break;
+                }
+            }
+        }
+
+        // Adapted from rpc/mining.cpp
+        class submitblock_StateCatcher final : public CValidationInterface {
+        public:
+            BlockHash hash;
+            bool found;
+            BlockValidationState state;
+
+            explicit submitblock_StateCatcher(const BlockHash &hashIn)
+                : hash(hashIn), found(false), state() {}
+
+        protected:
+            void BlockChecked(const CBlock &block,
+                              const BlockValidationState &stateIn) override {
+                if (block.GetHash() != hash) {
+                    return;
+                }
+                found = true;
+                state = stateIn;
+            }
+        };
+
+        bool new_block;
+        auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
+        RegisterSharedValidationInterface(sc);
+        bool accepted = chainman.ProcessNewBlock(config, blockptr,
+                                                 /*force_processing=*/true,
+                                                 /*new_block=*/&new_block);
+        UnregisterSharedValidationInterface(sc);
+        if (!new_block && accepted) {
+            std::cerr << "Duplicate" << std::endl;
+            break;
+        }
+        if (!sc->found) {
+            std::cerr << "Inconclusive" << std::endl;
+            break;
+        }
+        std::cout << sc->state.ToString() << std::endl;
+        switch (sc->state.GetResult()) {
+            case BlockValidationResult::BLOCK_RESULT_UNSET:
+                std::cerr << "Initial value. Block has not yet been rejected"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_CONSENSUS:
+                std::cerr << "Invalid by consensus rules (excluding any below "
+                             "reasons)"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_CACHED_INVALID:
+                std::cerr << "This block was cached as being invalid and we "
+                             "didn't store the reason why"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_INVALID_HEADER:
+                std::cerr << "Invalid proof of work or time too old"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_MUTATED:
+                std::cerr << "The block's data didn't match the data committed "
+                             "to by the PoW"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_MISSING_PREV:
+                std::cerr << "We don't have the previous block the checked one "
+                             "is built on"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_INVALID_PREV:
+                std::cerr << "A block this one builds on is invalid"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_TIME_FUTURE:
+                std::cerr << "Block timestamp was > 2 hours in the future (or "
+                             "our clock is bad)"
+                          << std::endl;
+                break;
+            case BlockValidationResult::BLOCK_CHECKPOINT:
+                std::cerr << "The block failed to meet one of our checkpoints"
+                          << std::endl;
+                break;
+        }
+    }
+
+epilogue:
+    // Without this precise shutdown sequence, there will be a lot of nullptr
+    // dereferencing and UB.
+    scheduler.stop();
+    if (chainman.m_load_block.joinable()) {
+        chainman.m_load_block.join();
+    }
+    StopScriptCheckWorkerThreads();
+
+    GetMainSignals().FlushBackgroundCallbacks();
+    {
+        LOCK(cs_main);
+        for (Chainstate *chainstate : chainman.GetAll()) {
+            if (chainstate->CanFlushToDisk()) {
+                chainstate->ForceFlushStateToDisk();
+                chainstate->ResetCoinsViews();
+            }
+        }
+    }
+    GetMainSignals().UnregisterBackgroundSignalScheduler();
+
+    init::UnsetGlobals();
+}