diff --git a/bin/verilator b/bin/verilator
index 8779c7344..d1d40944e 100755
--- a/bin/verilator
+++ b/bin/verilator
@@ -526,7 +526,6 @@ detailed descriptions of these arguments.
     --trace-params              Enable tracing of parameters
     --trace-saif                Enable SAIF file creation
     --trace-structs             Enable tracing structure names
-    --trace-threads <threads>   Enable FST waveform creation on separate threads
     --no-trace-top              Do not emit traces for signals in the top module generated by verilator
     --trace-underscore          Enable tracing of _signals
     --trace-vcd                 Enable VCD waveform creation
diff --git a/docs/guide/exe_verilator.rst b/docs/guide/exe_verilator.rst
index ca2232426..dd16f6b19 100644
--- a/docs/guide/exe_verilator.rst
+++ b/docs/guide/exe_verilator.rst
@@ -1825,7 +1825,7 @@ Summary:
 .. option:: --trace-fst
 
    Enable FST waveform tracing in the model. This overrides
-   :vlopt:`--trace`. See also :vlopt:`--trace-threads` option.
+   :vlopt:`--trace`.
 
 .. option:: --trace-max-array <depth>
 
@@ -1859,6 +1859,10 @@ Summary:
 
 .. option:: --trace-threads <threads>
 
+   Deprecated and has no effect.
+
+   In versions before 5.048:
+
    Enable waveform tracing using separate threads. This is typically faster
    in simulation runtime but uses more total compute. This option only
    applies to :vlopt:`--trace-fst`. FST tracing can utilize at most
diff --git a/docs/guide/verilating.rst b/docs/guide/verilating.rst
index 377686548..a91eb66b9 100644
--- a/docs/guide/verilating.rst
+++ b/docs/guide/verilating.rst
@@ -262,23 +262,6 @@ construction is parallelized using the same number of threads as specified
 with :vlopt:`--threads`, and is executed on the same thread pool as the
 model.
 
-The :vlopt:`--trace-threads` options can be used with :vlopt:`--trace-fst`
-to offload FST tracing using multiple threads. If :vlopt:`--trace-threads`
-is given without :vlopt:`--threads`, then :vlopt:`--trace-threads` will
-imply :vlopt:`--threads 1 <--threads>`, i.e., the support libraries will be
-thread safe.
-
-With :vlopt:`--trace-threads 0 <--trace-threads>`, trace dumps are produced
-on the main thread. This again gives the highest single-thread performance.
-
-With :vlopt:`--trace-threads {N} <--trace-threads>`, where N is at least 1,
-up to N additional threads will be created and managed by the trace files
-(e.g., VerilatedFstC), to offload construction of the trace dump. The main
-thread will be released to proceed with execution as soon as possible,
-though some main thread blocking is still necessary while capturing the
-trace. FST tracing can utilize up to 2 offload threads, so there is no use
-of setting :vlopt:`--trace-threads` higher than 2 at the moment.
-
 When running a multithreaded model, the default Linux task scheduler often
 works against the model by assuming short-lived threads and thus it often
 schedules threads using multiple hyperthreads within the same physical
@@ -293,8 +276,7 @@ disable automatic thread affinity. For more information, refer to
 :ref:`Environment`.
 
 For best performance, use the :command:`numactl` program to (when the
-threading count fits) select unique physical cores on the same socket. The
-same applies for :vlopt:`--trace-threads` as well.
+threading count fits) select unique physical cores on the same socket.
 
 As an example, if a model was Verilated with :vlopt:`--threads 4
 <--threads>`, we consult:
@@ -521,7 +503,10 @@ include directories and link to the SystemC libraries.
 
 .. describe:: TRACE_THREADS
 
-   Optional. Enable multithreaded FST trace; see :vlopt:`--trace-threads`.
+   Deprecated and has no effect.
+
+   Before Verialtor 5.048: Optional. Enable multithreaded FST trace; see
+   :vlopt:`--trace-threads`.
 
 .. describe:: TRACE_VCD
 
diff --git a/include/verilated_fst_c.cpp b/include/verilated_fst_c.cpp
index 3096765a5..a12e028fd 100644
--- a/include/verilated_fst_c.cpp
+++ b/include/verilated_fst_c.cpp
@@ -353,29 +353,9 @@ void VerilatedFst::declDoubleArray(uint32_t code, const char* name, int dtypenum
 //=============================================================================
 // Get/commit trace buffer
 
-VerilatedFst::Buffer* VerilatedFst::getTraceBuffer(uint32_t /*fidx*/) {
-    if (offload()) return new OffloadBuffer{*this};
-    return new Buffer{*this};
-}
+VerilatedFst::Buffer* VerilatedFst::getTraceBuffer(uint32_t /*fidx*/) { return new Buffer{*this}; }
 
-void VerilatedFst::commitTraceBuffer(VerilatedFst::Buffer* bufp) {
-    if (offload()) {
-        const OffloadBuffer* const offloadBufferp = static_cast<const OffloadBuffer*>(bufp);
-        if (offloadBufferp->m_offloadBufferWritep) {
-            m_offloadBufferWritep = offloadBufferp->m_offloadBufferWritep;
-            return;  // Buffer will be deleted by the offload thread
-        }
-    }
-    delete bufp;
-}
-
-//=============================================================================
-// Configure
-
-void VerilatedFst::configure(const VerilatedTraceConfig& config) {
-    // If at least one model requests the FST writer thread, then use it
-    m_useFstWriterThread |= config.m_useFstWriterThread;
-}
+void VerilatedFst::commitTraceBuffer(VerilatedFst::Buffer* bufp) { delete bufp; }
 
 //=============================================================================
 // VerilatedFstBuffer implementation
diff --git a/include/verilated_fst_c.h b/include/verilated_fst_c.h
index beab35565..8df4683f5 100644
--- a/include/verilated_fst_c.h
+++ b/include/verilated_fst_c.h
@@ -87,7 +87,7 @@ protected:
     void commitTraceBuffer(Buffer*) override;
 
     // Configure sub-class
-    void configure(const VerilatedTraceConfig&) override;
+    void configure(const VerilatedTraceConfig&) override {}
 
 public:
     //=========================================================================
@@ -206,7 +206,6 @@ class VerilatedFstBuffer VL_NOT_FINAL {
     friend VerilatedFst;
     friend VerilatedFst::Super;
     friend VerilatedFst::Buffer;
-    friend VerilatedFst::OffloadBuffer;
 
     VerilatedFst& m_owner;  // Trace file owning this buffer. Required by subclasses.
 
diff --git a/include/verilated_saif_c.h b/include/verilated_saif_c.h
index 11637d925..3ad4e630c 100644
--- a/include/verilated_saif_c.h
+++ b/include/verilated_saif_c.h
@@ -224,7 +224,6 @@ class VerilatedSaifBuffer VL_NOT_FINAL {
     friend VerilatedSaif;
     friend VerilatedSaif::Super;
     friend VerilatedSaif::Buffer;
-    friend VerilatedSaif::OffloadBuffer;
 
     VerilatedSaif& m_owner;  // Trace file owning this buffer. Required by subclasses.
     uint32_t m_fidx;  // Index of target activity accumulator
diff --git a/include/verilated_trace.h b/include/verilated_trace.h
index 15e3cd964..c274aaf96 100644
--- a/include/verilated_trace.h
+++ b/include/verilated_trace.h
@@ -43,8 +43,6 @@
 class VlThreadPool;
 template <typename T_Buffer>
 class VerilatedTraceBuffer;
-template <typename T_Buffer>
-class VerilatedTraceOffloadBuffer;
 
 //=============================================================================
 // Common enumerations
@@ -98,76 +96,6 @@ enum class VerilatedTraceSigType : uint8_t {
     TIME,
 };
 
-//=============================================================================
-// Offloaded tracing
-
-// A simple synchronized first in first out queue
-template <typename T>
-class VerilatedThreadQueue final {  // LCOV_EXCL_LINE  // lcov bug
-private:
-    mutable VerilatedMutex m_mutex;  // Protects m_queue
-    std::condition_variable_any m_cv;
-    std::deque<T> m_queue VL_GUARDED_BY(m_mutex);
-
-public:
-    // Put an element at the back of the queue
-    void put(T value) VL_MT_SAFE_EXCLUDES(m_mutex) {
-        const VerilatedLockGuard lock{m_mutex};
-        m_queue.push_back(value);
-        m_cv.notify_one();
-    }
-
-    // Put an element at the front of the queue
-    void put_front(T value) VL_MT_SAFE_EXCLUDES(m_mutex) {
-        const VerilatedLockGuard lock{m_mutex};
-        m_queue.push_front(value);
-        m_cv.notify_one();
-    }
-
-    // Get an element from the front of the queue. Blocks if none available
-    T get() VL_MT_SAFE_EXCLUDES(m_mutex) {
-        VerilatedLockGuard lock{m_mutex};
-        m_cv.wait(m_mutex, [this]() VL_REQUIRES(m_mutex) { return !m_queue.empty(); });
-        assert(!m_queue.empty());
-        T value = m_queue.front();
-        m_queue.pop_front();
-        return value;
-    }
-
-    // Non blocking get
-    bool tryGet(T& result) VL_MT_SAFE_EXCLUDES(m_mutex) {
-        const VerilatedLockGuard lockGuard{m_mutex};
-        if (m_queue.empty()) return false;
-        result = m_queue.front();
-        m_queue.pop_front();
-        return true;
-    }
-};
-
-// Commands used by thread tracing. Anonymous enum in class, as we want
-// it scoped, but we also want the automatic conversion to integer types.
-class VerilatedTraceOffloadCommand final {
-public:
-    // These must all fit in 4 bit at the moment, as the tracing routines
-    // pack parameters in the top bits.
-    enum : uint8_t {
-        CHG_BIT_0 = 0x0,
-        CHG_BIT_1 = 0x1,
-        CHG_CDATA = 0x2,
-        CHG_SDATA = 0x3,
-        CHG_IDATA = 0x4,
-        CHG_QDATA = 0x5,
-        CHG_WDATA = 0x6,
-        CHG_DOUBLE = 0x8,
-        CHG_EVENT = 0x9,
-        // TODO: full..
-        TIME_CHANGE = 0xc,
-        TRACE_BUFFER = 0xd,
-        END = 0xe,  // End of buffer
-        SHUTDOWN = 0xf  // Shutdown worker thread, also marks end of buffer
-    };
-};
-
 //=============================================================================
 // VerilatedTraceConfig
 
@@ -175,13 +103,9 @@ public:
 class VerilatedTraceConfig final {
 public:
     const bool m_useParallel;  // Use parallel tracing
-    const bool m_useOffloading;  // Offloading trace rendering
-    const bool m_useFstWriterThread;  // Use the separate FST writer thread
 
-    VerilatedTraceConfig(bool useParallel, bool useOffloading, bool useFstWriterThread)
-        : m_useParallel{useParallel}
-        , m_useOffloading{useOffloading}
-        , m_useFstWriterThread{useFstWriterThread} {}
+    VerilatedTraceConfig(bool useParallel)
+        : m_useParallel{useParallel} {}
 };
 
 //=============================================================================
@@ -208,27 +132,23 @@ template <typename T_Trace, typename T_Buffer>
 class VerilatedTrace VL_NOT_FINAL {
 public:
     using Buffer = VerilatedTraceBuffer<T_Buffer>;
-    using OffloadBuffer = VerilatedTraceOffloadBuffer<T_Buffer>;
 
     //=========================================================================
     // Generic tracing internals
 
     using initCb_t = void (*)(void*, T_Trace*, uint32_t);  // Type of init callbacks
     using dumpCb_t = void (*)(void*, Buffer*);  // Type of dump callbacks
-    using dumpOffloadCb_t = void (*)(void*, OffloadBuffer*);  // Type of offload dump callbacks
     using cleanupCb_t = void (*)(void*, T_Trace*);  // Type of cleanup callbacks
 
 private:
     // Give the buffer (both base and derived) access to the private bits
     friend T_Buffer;
     friend Buffer;
-    friend OffloadBuffer;
 
     struct CallbackRecord final {
         union {  // The callback
             const initCb_t m_initCb;
             const dumpCb_t m_dumpCb;
-            const dumpOffloadCb_t m_dumpOffloadCb;
             const cleanupCb_t m_cleanupCb;
         };
         const uint32_t m_fidx;  // The index of the tracing function
@@ -252,14 +172,6 @@ private:
             , m_name{}  // Don't care
             , m_nTraceCodes{0}  // Don't care
         {}
-        CallbackRecord(dumpOffloadCb_t cb, uint32_t fidx, void* userp)
-            : m_dumpOffloadCb{cb}
-            , m_fidx{fidx}
-            , m_userp{userp}
-            , m_isLibInstance{false}  // Don't care
-            , m_name{}  // Don't care
-            , m_nTraceCodes{0}  // Don't care
-        {}
         CallbackRecord(cleanupCb_t cb, void* userp)
             : m_cleanupCb{cb}
             , m_fidx{0}
@@ -270,7 +182,6 @@ private:
         {}
     };
 
-    bool m_offload = false;  // Use the offload thread
     bool m_parallel = false;  // Use parallel tracing
 
     struct ParallelWorkerData final {
@@ -300,11 +211,8 @@ private:
     std::vector<bool> m_sigs_enabledVec;  // Staging for m_sigs_enabledp
     std::vector<CallbackRecord> m_initCbs;  // Routines to initialize tracing
     std::vector<CallbackRecord> m_constCbs;  // Routines to perform const dump
-    std::vector<CallbackRecord> m_constOffloadCbs;  // Routines to perform offloaded const dump
     std::vector<CallbackRecord> m_fullCbs;  // Routines to perform full dump
-    std::vector<CallbackRecord> m_fullOffloadCbs;  // Routines to perform offloaded full dump
     std::vector<CallbackRecord> m_chgCbs;  // Routines to perform incremental dump
-    std::vector<CallbackRecord> m_chgOffloadCbs;  // Routines to perform offloaded incremental dump
     std::vector<CallbackRecord> m_cleanupCbs;  // Routines to call at the end of dump
     bool m_constDump = true;  // Whether a const dump is required on the next call to 'dump'
     bool m_fullDump = true;  // Whether a full dump is required on the next call to 'dump'
@@ -329,44 +237,13 @@ private:
     T_Trace* self() { return static_cast<T_Trace*>(this); }
 
     void runCallbacks(const std::vector<CallbackRecord>& cbVec);
-    void runOffloadedCallbacks(const std::vector<CallbackRecord>& cbVec);
 
     // Flush any remaining data for this file
     static void onFlush(void* selfp) VL_MT_UNSAFE_ONE;
     // Close the file on termination
     static void onExit(void* selfp) VL_MT_UNSAFE_ONE;
 
-    // Number of total offload buffers that have been allocated
-    uint32_t m_numOffloadBuffers = 0;
-    // Size of offload buffers
-    size_t m_offloadBufferSize = 0;
-    // Buffers handed to worker for processing
-    VerilatedThreadQueue<uint32_t*> m_offloadBuffersToWorker;
-    // Buffers returned from worker after processing
-    VerilatedThreadQueue<uint32_t*> m_offloadBuffersFromWorker;
-
-protected:
-    // Write pointer into current buffer
-    uint32_t* m_offloadBufferWritep = nullptr;
-    // End of offload buffer
-    uint32_t* m_offloadBufferEndp = nullptr;
-
 private:
-    // The offload worker thread itself
-    std::unique_ptr<std::thread> m_workerThread;
-
-    // Get a new offload buffer that can be populated. May block if none available
-    uint32_t* getOffloadBuffer();
-
-    // The function executed by the offload worker thread
-    void offloadWorkerThreadMain();
-
-    // Wait until given offload buffer is placed in m_offloadBuffersFromWorker
-    void waitForOffloadBuffer(const uint32_t* bufferp);
-
-    // Shut down and join worker, if it's running, otherwise do nothing
-    void shutdownOffloadWorker();
-
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedTrace);
 
@@ -395,7 +272,6 @@ protected:
     void closeBase();
     void flushBase();
 
-    bool offload() const { return m_offload; }
     bool parallel() const { return m_parallel; }
 
     // Return last ' ' separated word. Assumes string does not end in ' '.
@@ -453,11 +329,8 @@ public:
     void addInitCb(initCb_t cb, void* userp, const std::string& name, bool isLibInstance,
                    uint32_t nTraceCodes) VL_MT_SAFE;
     void addConstCb(dumpCb_t cb, uint32_t fidx, void* userp) VL_MT_SAFE;
-    void addConstCb(dumpOffloadCb_t cb, uint32_t fidx, void* userp) VL_MT_SAFE;
     void addFullCb(dumpCb_t cb, uint32_t fidx, void* userp) VL_MT_SAFE;
-    void addFullCb(dumpOffloadCb_t cb, uint32_t fidx, void* userp) VL_MT_SAFE;
     void addChgCb(dumpCb_t cb, uint32_t fidx, void* userp) VL_MT_SAFE;
-    void addChgCb(dumpOffloadCb_t cb, uint32_t fidx, void* userp) VL_MT_SAFE;
     void addCleanupCb(cleanupCb_t cb, void* userp) VL_MT_SAFE;
     void initLib(const std::string& name) VL_MT_UNSAFE;
 };
@@ -517,10 +390,6 @@ public:
     void fullEvent(uint32_t* oldp, const VlEventBase* newvalp);
     void fullEventTriggered(uint32_t* oldp);
 
-    // In non-offload mode, these are called directly by the trace callbacks,
-    // and are called chg*. In offload mode, they are called by the worker
-    // thread and are called chg*Impl
-
     // Check previous dumped value of signal. If changed, then emit trace entry
     VL_ATTR_ALWINLINE void chgBit(uint32_t* oldp, CData newval) {
         const uint32_t diff = *oldp ^ newval;
@@ -563,86 +432,4 @@ public:
     }
 };
 
-//=============================================================================
-// VerilatedTraceOffloadBuffer
-
-// T_Buffer is the format-specific base class of VerilatedTraceBuffer.
-// The format-specific hot-path methods use duck-typing via T_Buffer for performance.
-template <typename T_Buffer>
-class VerilatedTraceOffloadBuffer final : public VerilatedTraceBuffer<T_Buffer> {
-    using typename VerilatedTraceBuffer<T_Buffer>::Trace;
-
-    friend Trace;  // Give the trace file access to the private bits
-
-    uint32_t* m_offloadBufferWritep;  // Write pointer into current buffer
-    uint32_t* const m_offloadBufferEndp;  // End of offload buffer
-
-    explicit VerilatedTraceOffloadBuffer(Trace& owner);
-    ~VerilatedTraceOffloadBuffer() override = default;
-
-public:
-    //=========================================================================
-    // Hot path internal interface to Verilator generated code
-
-    // Offloaded tracing. Just dump everything in the offload buffer
-    void chgBit(uint32_t code, CData newval) {
-        m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::CHG_BIT_0 | newval;
-        m_offloadBufferWritep[1] = code;
-        m_offloadBufferWritep += 2;
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-    void chgCData(uint32_t code, CData newval, int bits) {
-        m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_CDATA;
-        m_offloadBufferWritep[1] = code;
-        m_offloadBufferWritep[2] = newval;
-        m_offloadBufferWritep += 3;
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-    void chgSData(uint32_t code, SData newval, int bits) {
-        m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_SDATA;
-        m_offloadBufferWritep[1] = code;
-        m_offloadBufferWritep[2] = newval;
-        m_offloadBufferWritep += 3;
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-    void chgIData(uint32_t code, IData newval, int bits) {
-        m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_IDATA;
-        m_offloadBufferWritep[1] = code;
-        m_offloadBufferWritep[2] = newval;
-        m_offloadBufferWritep += 3;
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-    void chgQData(uint32_t code, QData newval, int bits) {
-        m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_QDATA;
-        m_offloadBufferWritep[1] = code;
-        *reinterpret_cast<QData*>(m_offloadBufferWritep + 2) = newval;
-        m_offloadBufferWritep += 4;
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-    void chgWData(uint32_t code, const WData* newvalp, int bits) {
-        m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_WDATA;
-        m_offloadBufferWritep[1] = code;
-        m_offloadBufferWritep += 2;
-        for (int i = 0; i < (bits + 31) / 32; ++i) *m_offloadBufferWritep++ = newvalp[i];
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-    void chgDouble(uint32_t code, double newval) {
-        m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::CHG_DOUBLE;
-        m_offloadBufferWritep[1] = code;
-        // cppcheck-suppress invalidPointerCast
-        *reinterpret_cast<double*>(m_offloadBufferWritep + 2) = newval;
-        m_offloadBufferWritep += 4;
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-    void chgEvent(uint32_t code, const VlEventBase* newvalp) {
-        if (newvalp->isTriggered()) chgEventTriggered(code);
-    }
-    void chgEventTriggered(uint32_t code) {
-        m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::CHG_EVENT;
-        m_offloadBufferWritep[1] = code;
-        m_offloadBufferWritep += 2;
-        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
-    }
-};
-
 #endif  // guard
diff --git a/include/verilated_trace_imp.h b/include/verilated_trace_imp.h
index 635e3e897..bc6c54019 100644
--- a/include/verilated_trace_imp.h
+++ b/include/verilated_trace_imp.h
@@ -29,13 +29,6 @@
 #include "verilated_threads.h"
 #include <list>
 
-#if 0
-# include <iostream>
-# define VL_TRACE_OFFLOAD_DEBUG(msg) std::cout << "TRACE OFFLOAD THREAD: " << msg << "\n"
-#else
-# define VL_TRACE_OFFLOAD_DEBUG(msg)
-#endif
-
 // clang-format on
 
 //=============================================================================
@@ -60,210 +53,14 @@ static double timescaleToDouble(const char* unitp) VL_PURE {
     return value;
 }
 
-//=========================================================================
-// Buffer management
-
-template <>
-uint32_t* VerilatedTrace<VL_SUB_T, VL_BUF_T>::getOffloadBuffer() {
-    uint32_t* bufferp;
-    // Some jitter is expected, so some number of alternative offload buffers are
-    // required, but don't allocate more than 8 buffers.
-    if (m_numOffloadBuffers < 8) {
-        // Allocate a new buffer if none is available
-        if (!m_offloadBuffersFromWorker.tryGet(bufferp)) {
-            ++m_numOffloadBuffers;
-            // Note: over allocate a bit so pointer comparison is well defined
-            // if we overflow only by a small amount
-            bufferp = new uint32_t[m_offloadBufferSize + 16];
-        }
-    } else {
-        // Block until a buffer becomes available
-        bufferp = m_offloadBuffersFromWorker.get();
-    }
-    return bufferp;
-}
-
-template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::waitForOffloadBuffer(const uint32_t* buffp) {
-    // Slow path code only called on flush/shutdown, so use a simple algorithm.
-    // Collect buffers from worker and stash them until we get the one we want.
-    std::deque<uint32_t*> stash;
-    do { stash.push_back(m_offloadBuffersFromWorker.get()); } while (stash.back() != buffp);
-    // Now put them back in the queue, in the original order.
-    while (!stash.empty()) {
-        m_offloadBuffersFromWorker.put_front(stash.back());
-        stash.pop_back();
-    }
-}
-
-//=========================================================================
-// Worker thread
-
-template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::offloadWorkerThreadMain() {
-    bool shutdown = false;
-
-    do {
-        uint32_t* const bufferp = m_offloadBuffersToWorker.get();
-
-        VL_TRACE_OFFLOAD_DEBUG("");
-        VL_TRACE_OFFLOAD_DEBUG("Got buffer: " << bufferp);
-
-        const uint32_t* readp = bufferp;
-
-        std::unique_ptr<Buffer> traceBufp;  // We own the passed tracebuffer
-
-        while (true) {
-            const uint32_t cmd = readp[0];
-            const uint32_t top = cmd >> 4;
-            // Always set this up, as it is almost always needed
-            uint32_t* const oldp = m_sigs_oldvalp + readp[1];
-            // Note this increment needs to be undone on commands which do not
-            // actually contain a code, but those are the rare cases.
-            readp += 2;
-
-            switch (cmd & 0xF) {
-                //===
-                // CHG_* commands
-            case VerilatedTraceOffloadCommand::CHG_BIT_0:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_BIT_0 " << top);
-                traceBufp->chgBit(oldp, 0);
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_BIT_1:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_BIT_1 " << top);
-                traceBufp->chgBit(oldp, 1);
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_CDATA:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_CDATA " << top);
-                // Bits stored in bottom byte of command
-                traceBufp->chgCData(oldp, *readp, top);
-                readp += 1;
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_SDATA:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_SDATA " << top);
-                // Bits stored in bottom byte of command
-                traceBufp->chgSData(oldp, *readp, top);
-                readp += 1;
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_IDATA:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_IDATA " << top);
-                // Bits stored in bottom byte of command
-                traceBufp->chgIData(oldp, *readp, top);
-                readp += 1;
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_QDATA:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_QDATA " << top);
-                // Bits stored in bottom byte of command
-                traceBufp->chgQData(oldp, *reinterpret_cast<const QData*>(readp), top);
-                readp += 2;
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_WDATA:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_WDATA " << top);
-                traceBufp->chgWData(oldp, readp, top);
-                readp += VL_WORDS_I(top);
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_DOUBLE:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_DOUBLE " << top);
-                traceBufp->chgDouble(oldp, *reinterpret_cast<const double*>(readp));
-                readp += 2;
-                continue;
-            case VerilatedTraceOffloadCommand::CHG_EVENT:
-                VL_TRACE_OFFLOAD_DEBUG("Command CHG_EVENT " << top);
-                traceBufp->chgEventTriggered(oldp);
-                continue;
-
-                //===
-                // Rare commands
-            case VerilatedTraceOffloadCommand::TIME_CHANGE: {
-                VL_TRACE_OFFLOAD_DEBUG("Command TIME_CHANGE " << top);
-                readp -= 1;  // No code in this command, undo increment
-                const uint64_t timeui
-                    = static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(readp)) << 32ULL
-                      | static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(readp + 1));
-                emitTimeChange(timeui);
-                readp += 2;
-                continue;
-            }
-            case VerilatedTraceOffloadCommand::TRACE_BUFFER:
-                VL_TRACE_OFFLOAD_DEBUG("Command TRACE_BUFFER " << top);
-                readp -= 1;  // No code in this command, undo increment
-                traceBufp.reset(*reinterpret_cast<Buffer* const*>(readp));
-                readp += 2;
-                continue;
-
-                //===
-                // Commands ending this buffer
-            case VerilatedTraceOffloadCommand::END:  //
-                VL_TRACE_OFFLOAD_DEBUG("Command END");
-                break;
-            case VerilatedTraceOffloadCommand::SHUTDOWN:
-                VL_TRACE_OFFLOAD_DEBUG("Command SHUTDOWN");
-                shutdown = true;
-                break;
-
-            //===
-            // Unknown command
-            default: {  // LCOV_EXCL_START
-                VL_TRACE_OFFLOAD_DEBUG("Command UNKNOWN " << cmd);
-                VL_FATAL_MT(__FILE__, __LINE__, "", "Unknown trace command");
-                break;
-            }  // LCOV_EXCL_STOP
-            }
-
-            // The above switch will execute 'continue' when necessary,
-            // so if we ever reach here, we are done with the buffer.
-            break;
-        }
-
-        VL_TRACE_OFFLOAD_DEBUG("Returning buffer");
-
-        // Return buffer
-        m_offloadBuffersFromWorker.put(bufferp);
-    } while (VL_LIKELY(!shutdown));
-}
-
-template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::shutdownOffloadWorker() {
-    // If the worker thread is not running, done..
-    if (!m_workerThread) return;
-
-    // Hand an buffer with a shutdown command to the worker thread
-    uint32_t* const bufferp = getOffloadBuffer();
-    bufferp[0] = VerilatedTraceOffloadCommand::SHUTDOWN;
-    m_offloadBuffersToWorker.put(bufferp);
-    // Wait for it to return
-    waitForOffloadBuffer(bufferp);
-    // Join the thread and delete it
-    m_workerThread->join();
-    m_workerThread.reset(nullptr);
-}
-
 //=============================================================================
 // Life cycle
 
 template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::closeBase() {
-    if (offload()) {
-        shutdownOffloadWorker();
-        while (m_numOffloadBuffers) {
-            delete[] m_offloadBuffersFromWorker.get();
-            --m_numOffloadBuffers;
-        }
-    }
-}
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::closeBase() {}
 
 template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::flushBase() {
-    if (offload()) {
-        // Hand an empty buffer to the worker thread
-        uint32_t* const bufferp = getOffloadBuffer();
-        *bufferp = VerilatedTraceOffloadCommand::END;
-        m_offloadBuffersToWorker.put(bufferp);
-        // Wait for it to be returned. As the processing is in-order,
-        // this ensures all previous buffers have been processed.
-        waitForOffloadBuffer(bufferp);
-    }
-}
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::flushBase() {}
 
 //=============================================================================
 // Callbacks to run on global events
@@ -295,7 +92,6 @@ VerilatedTrace<VL_SUB_T, VL_BUF_T>::~VerilatedTrace() {
     if (m_sigs_enabledp) VL_DO_CLEAR(delete[] m_sigs_enabledp, m_sigs_enabledp = nullptr);
     Verilated::removeFlushCb(VerilatedTrace<VL_SUB_T, VL_BUF_T>::onFlush, this);
     Verilated::removeExitCb(VerilatedTrace<VL_SUB_T, VL_BUF_T>::onExit, this);
-    if (offload()) closeBase();
 }
 
 //=========================================================================
@@ -353,19 +149,6 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::traceInit() VL_MT_UNSAFE {
     // Set callback so flush/abort will flush this file
     Verilated::addFlushCb(VerilatedTrace<VL_SUB_T, VL_BUF_T>::onFlush, this);
     Verilated::addExitCb(VerilatedTrace<VL_SUB_T, VL_BUF_T>::onExit, this);
-
-    if (offload()) {
-        // Compute offload buffer size. we need to be able to store a new value for
-        // each signal, which is 'nextCode()' entries after the init callbacks
-        // above have been run, plus up to 2 more words of metadata per signal,
-        // plus fixed overhead of 1 for a termination flag and 3 for a time stamp
-        // update and 2 for the buffer address.
-        m_offloadBufferSize = nextCode() + numSignals() * 2 + 6;
-
-        // Start the worker thread
-        m_workerThread.reset(
-            new std::thread{&VerilatedTrace<VL_SUB_T, VL_BUF_T>::offloadWorkerThreadMain, this});
-    }
 }
 
 template <>
@@ -520,17 +303,6 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::runCallbacks(const std::vector<Callback
     }
 }
 
-template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::runOffloadedCallbacks(
-    const std::vector<CallbackRecord>& cbVec) {
-    // Fall back on sequential execution
-    for (const CallbackRecord& cbr : cbVec) {
-        Buffer* traceBufferp = getTraceBuffer(cbr.m_fidx);
-        cbr.m_dumpOffloadCb(cbr.m_userp, static_cast<OffloadBuffer*>(traceBufferp));
-        commitTraceBuffer(traceBufferp);
-    }
-}
-
 template <>
 void VerilatedTrace<VL_SUB_T, VL_BUF_T>::dump(uint64_t timeui) VL_MT_SAFE_EXCLUDES(m_mutex) {
     // Not really VL_MT_SAFE but more VL_MT_UNSAFE_ONE.
@@ -556,72 +328,23 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::dump(uint64_t timeui) VL_MT_SAFE_EXCLUD
     }
 
     uint32_t* bufferp = nullptr;
-    if (offload()) {
-        // Currently only incremental dumps run on the worker thread
-        if (VL_LIKELY(!m_fullDump)) {
-            // Get the offload buffer we are about to fill
-            bufferp = getOffloadBuffer();
-            m_offloadBufferWritep = bufferp;
-            m_offloadBufferEndp = bufferp + m_offloadBufferSize;
-
-            // Tell worker to update time point
-            m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::TIME_CHANGE;
-            *reinterpret_cast<uint32_t*>(m_offloadBufferWritep + 1)
-                = static_cast<uint32_t>(timeui >> 32ULL);
-            *reinterpret_cast<uint32_t*>(m_offloadBufferWritep + 2)
-                = static_cast<uint32_t>(timeui);
-            m_offloadBufferWritep += 3;
-        } else {
-            // Update time point
-            flushBase();
-            emitTimeChange(timeui);
-        }
-    } else {
-        // Update time point
-        emitTimeChange(timeui);
-    }
+    // Update time point
+    emitTimeChange(timeui);
 
     // Run the callbacks
     if (VL_UNLIKELY(m_fullDump)) {
         m_fullDump = false;  // No more need for next dump to be full
-        if (offload()) {
-            runOffloadedCallbacks(m_fullOffloadCbs);
-        } else {
-            runCallbacks(m_fullCbs);
-        }
+        runCallbacks(m_fullCbs);
     } else {
-        if (offload()) {
-            runOffloadedCallbacks(m_chgOffloadCbs);
-        } else {
-            runCallbacks(m_chgCbs);
-        }
+        runCallbacks(m_chgCbs);
     }
 
     if (VL_UNLIKELY(m_constDump)) {
         m_constDump = false;
-        if (offload()) {
-            runOffloadedCallbacks(m_constOffloadCbs);
-        } else {
-            runCallbacks(m_constCbs);
-        }
+        runCallbacks(m_constCbs);
     }
 
     for (const CallbackRecord& cbr : m_cleanupCbs) cbr.m_cleanupCb(cbr.m_userp, self());
-
-    if (offload() && VL_LIKELY(bufferp)) {
-        // Mark end of the offload buffer we just filled
-        *m_offloadBufferWritep++ = VerilatedTraceOffloadCommand::END;
-
-        // Assert no buffer overflow
-        assert(static_cast<size_t>(m_offloadBufferWritep - bufferp) <= m_offloadBufferSize);
-
-        // Reset our pointers as we are giving up the buffer
-        m_offloadBufferWritep = nullptr;
-        m_offloadBufferEndp = nullptr;
-
-        // Pass it to the worker thread
-        m_offloadBuffersToWorker.put(bufferp);
-    }
 }
 
 //=============================================================================
@@ -658,20 +381,9 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addModel(VerilatedModel* modelp)
     const std::unique_ptr<VerilatedTraceConfig> configp = modelp->traceConfig();
 
     // Configure trace base class
-    if (!firstModel) {
-        if (m_offload != configp->m_useOffloading) {
-            VL_FATAL_MT(__FILE__, __LINE__, "",
-                        "Either all or no models using the same trace file must use offloading");
-        }
-    }
-    m_offload = configp->m_useOffloading;
     // If at least one model requests parallel tracing, then use it
     m_parallel |= configp->m_useParallel;
 
-    if (VL_UNCOVERABLE(m_parallel && m_offload)) {  // LCOV_EXCL_START
-        VL_FATAL_MT(__FILE__, __LINE__, "", "Cannot use parallel tracing with offloading");
-    }  // LCOV_EXCL_STOP
-
     // Configure format-specific sub class
     configure(*(configp.get()));
 }
@@ -696,31 +408,16 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addConstCb(dumpCb_t cb, uint32_t fidx,
     addCallbackRecord(m_constCbs, CallbackRecord{cb, fidx, userp});
 }
 template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addConstCb(dumpOffloadCb_t cb, uint32_t fidx,
-                                                    void* userp) VL_MT_SAFE {
-    addCallbackRecord(m_constOffloadCbs, CallbackRecord{cb, fidx, userp});
-}
-template <>
 void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addFullCb(dumpCb_t cb, uint32_t fidx,
                                                    void* userp) VL_MT_SAFE {
     addCallbackRecord(m_fullCbs, CallbackRecord{cb, fidx, userp});
 }
 template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addFullCb(dumpOffloadCb_t cb, uint32_t fidx,
-                                                   void* userp) VL_MT_SAFE {
-    addCallbackRecord(m_fullOffloadCbs, CallbackRecord{cb, fidx, userp});
-}
-template <>
 void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addChgCb(dumpCb_t cb, uint32_t fidx,
                                                   void* userp) VL_MT_SAFE {
     addCallbackRecord(m_chgCbs, CallbackRecord{cb, fidx, userp});
 }
 template <>
-void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addChgCb(dumpOffloadCb_t cb, uint32_t fidx,
-                                                  void* userp) VL_MT_SAFE {
-    addCallbackRecord(m_chgOffloadCbs, CallbackRecord{cb, fidx, userp});
-}
-template <>
 void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addCleanupCb(cleanupCb_t cb, void* userp) VL_MT_SAFE {
     addCallbackRecord(m_cleanupCbs, CallbackRecord{cb, userp});
 }
@@ -914,23 +611,4 @@ void VerilatedTraceBuffer<VL_BUF_T>::fullDouble(uint32_t* oldp, double newval) {
     emitDouble(code, newval);
 }
 
-//=========================================================================
-// VerilatedTraceOffloadBuffer
-
-template <>
-VerilatedTraceOffloadBuffer<VL_BUF_T>::VerilatedTraceOffloadBuffer(VL_SUB_T& owner)
-    : VerilatedTraceBuffer<VL_BUF_T>{owner}
-    , m_offloadBufferWritep{owner.m_offloadBufferWritep}
-    , m_offloadBufferEndp{owner.m_offloadBufferEndp} {
-    if (m_offloadBufferWritep) {
-        using This = VerilatedTraceBuffer<VL_BUF_T>*;
-        // Tack on the buffer address
-        static_assert(2 * sizeof(uint32_t) >= sizeof(This),
-                      "This should be enough on all platforms");
-        *m_offloadBufferWritep++ = VerilatedTraceOffloadCommand::TRACE_BUFFER;
-        *reinterpret_cast<This*>(m_offloadBufferWritep) = static_cast<This>(this);
-        m_offloadBufferWritep += 2;
-    }
-}
-
 #endif  // VL_CPPCHECK
diff --git a/include/verilated_vcd_c.cpp b/include/verilated_vcd_c.cpp
index 3e0552752..1ee7443f0 100644
--- a/include/verilated_vcd_c.cpp
+++ b/include/verilated_vcd_c.cpp
@@ -278,7 +278,6 @@ void VerilatedVcd::bufferResize(size_t minsize) {
 }
 
 void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
-    // This function can be called from the trace offload thread
     // This function is on the flush() call path
     // We add output data to m_writep.
     // When it gets nearly full we dump it using this routine which calls write()
diff --git a/include/verilated_vcd_c.h b/include/verilated_vcd_c.h
index 4731facfe..f71e2513c 100644
--- a/include/verilated_vcd_c.h
+++ b/include/verilated_vcd_c.h
@@ -211,7 +211,6 @@ class VerilatedVcdBuffer VL_NOT_FINAL {
     friend VerilatedVcd;
     friend VerilatedVcd::Super;
     friend VerilatedVcd::Buffer;
-    friend VerilatedVcd::OffloadBuffer;
 
     VerilatedVcd& m_owner;  // Trace file owning this buffer. Required by subclasses.
 
diff --git a/src/V3EmitCImp.cpp b/src/V3EmitCImp.cpp
index eebca7f66..eb7eb4718 100644
--- a/src/V3EmitCImp.cpp
+++ b/src/V3EmitCImp.cpp
@@ -752,9 +752,7 @@ class EmitCTrace final : public EmitCFunc {
         const uint32_t offset = (arrayindex < 0) ? 0 : (arrayindex * nodep->declp()->widthWords());
         const uint32_t code = nodep->declp()->code() + offset;
         // Note: Both VTraceType::CHANGE and VTraceType::FULL use the 'full' methods
-        puts(v3Global.opt.useTraceOffload() && nodep->traceType() == VTraceType::CHANGE
-                 ? "(base+"
-                 : "(oldp+");
+        puts("(oldp+");
         puts(cvtToStr(code - nodep->baseCode()));
         puts(",");
         const VNumRange& arrayRange = nodep->declp()->arrayRange();
diff --git a/src/V3EmitCModel.cpp b/src/V3EmitCModel.cpp
index 340c0587a..cc8648a2e 100644
--- a/src/V3EmitCModel.cpp
+++ b/src/V3EmitCModel.cpp
@@ -519,8 +519,6 @@ class EmitCModel final : public EmitCFunc {
                             + "::traceConfig() const {\n");
             puts("return std::unique_ptr<VerilatedTraceConfig>{new VerilatedTraceConfig{");
             puts(v3Global.opt.useTraceParallel() ? "true" : "false");
-            puts(v3Global.opt.useTraceOffload() ? ", true" : ", false");
-            puts(v3Global.opt.useFstWriterThread() ? ", true" : ", false");
             puts("}};\n");
             puts("};\n");
         }
diff --git a/src/V3Options.cpp b/src/V3Options.cpp
index d7ef86388..4d01fa1ec 100644
--- a/src/V3Options.cpp
+++ b/src/V3Options.cpp
@@ -1039,14 +1039,6 @@ void V3Options::notify() VL_MT_DISABLED {
     if (m_timing.isDefault() && (v3Global.opt.jsonOnly() || v3Global.opt.lintOnly()))
         v3Global.opt.m_timing.setTrueOrFalse(true);
 
-    if (trace()) {
-        // With --trace-vcd, --trace-threads is ignored
-        if (traceEnabledVcd()) m_traceThreads = 1;
-    }
-
-    UASSERT(!(useTraceParallel() && useTraceOffload()),
-            "Cannot use both parallel and offloaded tracing");
-
     // Default split limits if not specified
     if (m_outputSplitCFuncs < 0) m_outputSplitCFuncs = m_outputSplit;
     if (m_outputSplitCTrace < 0) m_outputSplitCTrace = m_outputSplit;
@@ -1822,22 +1814,16 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc,
         m_traceEnabledFst = true;
         addLdLibs("-lz");
     });
-    DECL_OPTION("-trace-fst-thread", CbCall, [this, fl]() {
-        m_traceEnabledFst = true;
-        addLdLibs("-lz");
-        fl->v3warn(DEPRECATED, "Option --trace-fst-thread is deprecated. "
-                               "Use --trace-fst with --trace-threads > 0.");
-        if (m_traceThreads == 0) m_traceThreads = 1;
+    DECL_OPTION("-trace-fst-thread", CbCall, [fl]() {
+        fl->v3warn(DEPRECATED, "Option '--trace-fst-thread' is deprecated and has no effect.");
     }).undocumented();
     DECL_OPTION("-trace-max-array", Set, &m_traceMaxArray);
     DECL_OPTION("-trace-max-width", Set, &m_traceMaxWidth);
     DECL_OPTION("-trace-params", OnOff, &m_traceParams);
     DECL_OPTION("-trace-structs", OnOff, &m_traceStructs);
-    DECL_OPTION("-trace-threads", CbVal, [this, fl](const char* valp) {
-        m_trace = true;
-        m_traceThreads = std::atoi(valp);
-        if (m_traceThreads < 1) fl->v3fatal("--trace-threads must be >= 1: " << valp);
-    });
+    DECL_OPTION("-trace-threads", CbVal, [fl](const char*) {
+        fl->v3warn(DEPRECATED, "Option '--trace-threads' is deprecated and has no effect.");
+    }).undocumented();
     DECL_OPTION("-no-trace-top", Set, &m_noTraceTop);
     DECL_OPTION("-trace-underscore", OnOff, &m_traceUnderscore);
     DECL_OPTION("-trace-vcd", CbCall, [this]() { m_traceEnabledVcd = true; });
diff --git a/src/V3Options.h b/src/V3Options.h
index 7e2e50f10..d99dd69de 100644
--- a/src/V3Options.h
+++ b/src/V3Options.h
@@ -351,7 +351,6 @@ private:
     int         m_traceDepth = 0;   // main switch: --trace-depth
     int         m_traceMaxArray = 32;  // main switch: --trace-max-array
     int         m_traceMaxWidth = 4096; // main switch: --trace-max-width
-    int         m_traceThreads = 0; // main switch: --trace-threads
     int         m_unrollCount = 64;  // main switch: --unroll-count
     int         m_unrollLimit = 16384;  // main switch: --unroll-limit
     int         m_unrollStmts = 30000;  // main switch: --unroll-stmts
@@ -634,12 +633,9 @@ public:
     int traceDepth() const { return m_traceDepth; }
     int traceMaxArray() const { return m_traceMaxArray; }
     int traceMaxWidth() const { return m_traceMaxWidth; }
-    int traceThreads() const { return m_traceThreads; }
-    bool useTraceOffload() const { return trace() && traceEnabledFst() && traceThreads() > 1; }
     bool useTraceParallel() const {
         return trace() && traceEnabledVcd() && (threads() > 1 || hierChild() > 1);
     }
-    bool useFstWriterThread() const { return traceThreads() && traceEnabledFst(); }
     int unrollCount() const { return m_unrollCount; }
     int unrollLimit() const { return m_unrollLimit; }
     int unrollStmts() const { return m_unrollStmts; }
diff --git a/src/V3Trace.cpp b/src/V3Trace.cpp
index b4eb06234..e0471ff1c 100644
--- a/src/V3Trace.cpp
+++ b/src/V3Trace.cpp
@@ -666,8 +666,7 @@ class TraceVisitor final : public VNVisitor {
         // Add it to top scope
         m_topScopep->addBlocksp(funcp);
         const std::string bufArg
-            = v3Global.opt.traceClassBase()
-              + "::" + (v3Global.opt.useTraceOffload() ? "OffloadBuffer" : "Buffer") + "* bufp"
+            = v3Global.opt.traceClassBase() + "::Buffer* bufp"
               + (declp ? (", uint32_t offset, const " + declp->dtypep()->cType("", true, true)
                           + " __VdtypeVar")
                        : "");
@@ -710,21 +709,11 @@ class TraceVisitor final : public VNVisitor {
                                                   + (declp ? " + offset" : "") + ");\n"});
             } else {
                 // Change dump sub function
-                if (v3Global.opt.useTraceOffload()) {
-                    funcp->addStmtsp(new AstCStmt{flp,  //
-                                                  "const uint32_t base VL_ATTR_UNUSED = "
-                                                  "vlSymsp->__Vm_baseCode + "
-                                                      + (declp ? " offset" : cvtToStr(baseCode))
-                                                      + ";\n"});
-                    funcp->addStmtsp(
-                        new AstCStmt{flp, "(void)bufp;  // Prevent unused variable warning\n"});
-                } else {
-                    funcp->addStmtsp(new AstCStmt{flp,  //
-                                                  "uint32_t* const oldp VL_ATTR_UNUSED = "
-                                                  "bufp->oldp(vlSymsp->__Vm_baseCode + "
-                                                      + (declp ? " offset" : cvtToStr(baseCode))
-                                                      + ");\n"});
-                }
+                funcp->addStmtsp(new AstCStmt{flp,  //
+                                              "uint32_t* const oldp VL_ATTR_UNUSED = "
+                                              "bufp->oldp(vlSymsp->__Vm_baseCode + "
+                                                  + (declp ? " offset" : cvtToStr(baseCode))
+                                                  + ");\n"});
             }
             if (!declp) {
                 // Add call to top function
diff --git a/test_regress/CMakeLists.txt b/test_regress/CMakeLists.txt
index 0d89bf2bd..5934287ba 100644
--- a/test_regress/CMakeLists.txt
+++ b/test_regress/CMakeLists.txt
@@ -69,7 +69,6 @@ string(
 
 getarg(TEST_VERILATOR_ARGS_NORM "-prefix" TEST_PREFIX)
 getarg(TEST_VERILATOR_ARGS_NORM "-threads" TEST_THREADS)
-getarg(TEST_VERILATOR_ARGS_NORM "-trace-threads" TEST_TRACE_THREADS)
 
 # Strip unwanted args with 1 parameter
 string(
@@ -111,9 +110,6 @@ endif()
 if(TEST_THREADS)
     list(APPEND verilate_ARGS THREADS ${TEST_THREADS})
 endif()
-if(TEST_TRACE_THREADS)
-    list(APPEND verilate_ARGS TRACE_THREADS ${TEST_TRACE_THREADS})
-endif()
 if(TEST_SYSTEMC)
     list(APPEND verilate_ARGS SYSTEMC)
 endif()
diff --git a/test_regress/driver.py b/test_regress/driver.py
index 6f214145b..9489e1c8f 100755
--- a/test_regress/driver.py
+++ b/test_regress/driver.py
@@ -1148,8 +1148,6 @@ class VlTest:
             verilator_flags += ["--debug-partition"]
         if param['threads'] >= 0:
             verilator_flags += ["--threads", str(param['threads'])]
-        if param['vltmt'] and re.search(r'-trace-fst ', checkflags):
-            verilator_flags += ["--trace-threads 2"]
         if param['make_main'] and param['verilator_make_gmake']:
             verilator_flags += ["--exe"]
         if param['make_main'] and param['verilator_make_gmake']:
diff --git a/test_regress/t/t_dist_docs_options.py b/test_regress/t/t_dist_docs_options.py
index e4e768bcc..9ecb092c2 100755
--- a/test_regress/t/t_dist_docs_options.py
+++ b/test_regress/t/t_dist_docs_options.py
@@ -21,6 +21,7 @@ Doc_Waivers = [
     '-pp-comments',  # Deprecated
     '-prof-threads',  # Deprecated
     '-structs-packed',  # Deprecated
+    '-trace-threads',  # Deprecated
     '-xml-only',  # Removed
     '-xml-output',  # Removed
 ]
diff --git a/test_regress/t/t_flag_deprecated_bad.out b/test_regress/t/t_flag_deprecated_bad.out
index 50206313e..b05ea6277 100644
--- a/test_regress/t/t_flag_deprecated_bad.out
+++ b/test_regress/t/t_flag_deprecated_bad.out
@@ -1,6 +1,7 @@
-%Warning-DEPRECATED: Option --trace-fst-thread is deprecated. Use --trace-fst with --trace-threads > 0.
+%Warning-DEPRECATED: Option '--trace-fst-thread' is deprecated and has no effect.
                      ... For warning description see https://verilator.org/warn/DEPRECATED?v=latest
                      ... Use "/* verilator lint_off DEPRECATED */" and lint_on around source to disable this message.
+%Warning-DEPRECATED: Option '--trace-threads' is deprecated and has no effect.
 %Warning-DEPRECATED: Option order-clock-delay is deprecated and has no effect.
 %Warning-DEPRECATED: Option '--clk' is deprecated and has no effect.
 %Warning-DEPRECATED: Option '--no-clk' is deprecated and has no effect.
diff --git a/test_regress/t/t_flag_deprecated_bad.py b/test_regress/t/t_flag_deprecated_bad.py
index 48fd92091..c9370a2f7 100755
--- a/test_regress/t/t_flag_deprecated_bad.py
+++ b/test_regress/t/t_flag_deprecated_bad.py
@@ -12,7 +12,7 @@ import vltest_bootstrap
 test.scenarios('vlt')
 
 test.lint(verilator_flags2=[
-    "--trace-fst-thread --order-clock-delay --clk foo --no-clk bar -fno-dfg-pre-inline -fno-dfg-post-inline -fno-dfg-scoped"
+    "--trace-fst-thread --trace-threads 2 --order-clock-delay --clk foo --no-clk bar -fno-dfg-pre-inline -fno-dfg-post-inline -fno-dfg-scoped"
 ],
           fails=True,
           expect_filename=test.golden_filename)
diff --git a/test_regress/t/t_flag_trace_threads_bad.out b/test_regress/t/t_flag_trace_threads_bad.out
deleted file mode 100644
index f802e96ff..000000000
--- a/test_regress/t/t_flag_trace_threads_bad.out
+++ /dev/null
@@ -1,2 +0,0 @@
-%Error: --trace-threads must be >= 1: -1
-        ... See the manual at https://verilator.org/verilator_doc.html?v=latest for more assistance.
diff --git a/test_regress/t/t_flag_trace_threads_bad.py b/test_regress/t/t_flag_trace_threads_bad.py
deleted file mode 100755
index 8fd91771b..000000000
--- a/test_regress/t/t_flag_trace_threads_bad.py
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2024 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-
-test.scenarios('vlt')
-test.top_filename = 't/t_EXAMPLE.v'
-
-test.lint(verilator_flags2=["--trace-threads -1"],
-          fails=True,
-          expect_filename=test.golden_filename)
-
-test.passes()
diff --git a/test_regress/t/t_trace_array_cc_fst_threads_1.py b/test_regress/t/t_trace_array_cc_fst_threads_1.py
deleted file mode 100755
index 65d3ec5da..000000000
--- a/test_regress/t/t_trace_array_cc_fst_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_array_common
-
-test.scenarios('vlt_all')
-
-trace_array_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_array_cc_fst_threads_2.py b/test_regress/t/t_trace_array_cc_fst_threads_2.py
deleted file mode 100755
index 233ae9130..000000000
--- a/test_regress/t/t_trace_array_cc_fst_threads_2.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_array_common
-
-test.scenarios('vlt_all')
-
-trace_array_common.run(test, verilator_flags2=["--trace-threads", "2"])
diff --git a/test_regress/t/t_trace_array_cc_saif_threads_1.py b/test_regress/t/t_trace_array_cc_saif_threads_1.py
deleted file mode 100755
index 65d3ec5da..000000000
--- a/test_regress/t/t_trace_array_cc_saif_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_array_common
-
-test.scenarios('vlt_all')
-
-trace_array_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_array_cc_vcd_threads_1.py b/test_regress/t/t_trace_array_cc_vcd_threads_1.py
deleted file mode 100755
index 65d3ec5da..000000000
--- a/test_regress/t/t_trace_array_cc_vcd_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_array_common
-
-test.scenarios('vlt_all')
-
-trace_array_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_array_sc_fst_threads_1.py b/test_regress/t/t_trace_array_sc_fst_threads_1.py
deleted file mode 100755
index 65d3ec5da..000000000
--- a/test_regress/t/t_trace_array_sc_fst_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_array_common
-
-test.scenarios('vlt_all')
-
-trace_array_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_array_sc_fst_threads_2.py b/test_regress/t/t_trace_array_sc_fst_threads_2.py
deleted file mode 100755
index 233ae9130..000000000
--- a/test_regress/t/t_trace_array_sc_fst_threads_2.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_array_common
-
-test.scenarios('vlt_all')
-
-trace_array_common.run(test, verilator_flags2=["--trace-threads", "2"])
diff --git a/test_regress/t/t_trace_complex_default_cc_fst_threads_1.py b/test_regress/t/t_trace_complex_default_cc_fst_threads_1.py
deleted file mode 100755
index 8b4cfe063..000000000
--- a/test_regress/t/t_trace_complex_default_cc_fst_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_complex_common
-
-test.scenarios('vlt_all')
-
-trace_complex_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_complex_default_cc_fst_threads_2.py b/test_regress/t/t_trace_complex_default_cc_fst_threads_2.py
deleted file mode 100755
index 8afc840b9..000000000
--- a/test_regress/t/t_trace_complex_default_cc_fst_threads_2.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_complex_common
-
-test.scenarios('vlt_all')
-
-trace_complex_common.run(test, verilator_flags2=["--trace-threads", "2"])
diff --git a/test_regress/t/t_trace_complex_default_cc_saif_threads_1.py b/test_regress/t/t_trace_complex_default_cc_saif_threads_1.py
deleted file mode 100755
index 8b4cfe063..000000000
--- a/test_regress/t/t_trace_complex_default_cc_saif_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_complex_common
-
-test.scenarios('vlt_all')
-
-trace_complex_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_complex_default_cc_vcd_threads_1.py b/test_regress/t/t_trace_complex_default_cc_vcd_threads_1.py
deleted file mode 100755
index 8b4cfe063..000000000
--- a/test_regress/t/t_trace_complex_default_cc_vcd_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_complex_common
-
-test.scenarios('vlt_all')
-
-trace_complex_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_complex_default_sc_fst_threads_1.py b/test_regress/t/t_trace_complex_default_sc_fst_threads_1.py
deleted file mode 100755
index 8b4cfe063..000000000
--- a/test_regress/t/t_trace_complex_default_sc_fst_threads_1.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_complex_common
-
-test.scenarios('vlt_all')
-
-trace_complex_common.run(test, verilator_flags2=["--trace-threads", "1"])
diff --git a/test_regress/t/t_trace_complex_default_sc_fst_threads_2.py b/test_regress/t/t_trace_complex_default_sc_fst_threads_2.py
deleted file mode 100755
index 8afc840b9..000000000
--- a/test_regress/t/t_trace_complex_default_sc_fst_threads_2.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# DESCRIPTION: Verilator: Verilog Test driver/expect definition
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms of either the GNU Lesser General Public License Version 3
-# or the Perl Artistic License Version 2.0.
-# SPDX-FileCopyrightText: 2026 Wilson Snyder
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-import vltest_bootstrap
-import trace_complex_common
-
-test.scenarios('vlt_all')
-
-trace_complex_common.run(test, verilator_flags2=["--trace-threads", "2"])
diff --git a/test_regress/t/t_trace_two_dump_cc_fst.py b/test_regress/t/t_trace_two_dump_cc_fst.py
index 5c068c551..796e3105c 100755
--- a/test_regress/t/t_trace_two_dump_cc_fst.py
+++ b/test_regress/t/t_trace_two_dump_cc_fst.py
@@ -12,4 +12,4 @@ import trace_two_common
 
 test.scenarios('vlt_all')
 
-trace_two_common.run(test, verilator_flags2=["--trace-threads", "1"])
+trace_two_common.run(test)
diff --git a/test_regress/t/t_trace_two_hdr_cc_fst.py b/test_regress/t/t_trace_two_hdr_cc_fst.py
index 5c068c551..796e3105c 100755
--- a/test_regress/t/t_trace_two_hdr_cc_fst.py
+++ b/test_regress/t/t_trace_two_hdr_cc_fst.py
@@ -12,4 +12,4 @@ import trace_two_common
 
 test.scenarios('vlt_all')
 
-trace_two_common.run(test, verilator_flags2=["--trace-threads", "1"])
+trace_two_common.run(test)
diff --git a/test_regress/t/t_trace_two_port_cc_fst.py b/test_regress/t/t_trace_two_port_cc_fst.py
index 5c068c551..796e3105c 100755
--- a/test_regress/t/t_trace_two_port_cc_fst.py
+++ b/test_regress/t/t_trace_two_port_cc_fst.py
@@ -12,4 +12,4 @@ import trace_two_common
 
 test.scenarios('vlt_all')
 
-trace_two_common.run(test, verilator_flags2=["--trace-threads", "1"])
+trace_two_common.run(test)
diff --git a/test_regress/t/t_verilated_all.py b/test_regress/t/t_verilated_all.py
index 28cd6b097..871acac69 100755
--- a/test_regress/t/t_verilated_all.py
+++ b/test_regress/t/t_verilated_all.py
@@ -17,8 +17,7 @@ if not os.path.exists(test.root + "/.git"):
 test.compile(
     # Can't use --coverage and --savable together, so cheat and compile inline
     verilator_flags2=[
-        "--cc", "--coverage-toggle --coverage-line --coverage-user",
-        "--trace-vcd --vpi ", "--trace-threads 1",
+        "--cc", "--coverage-toggle --coverage-line --coverage-user", "--trace-vcd --vpi ",
         ("--timing" if test.have_coroutines else "--no-timing -Wno-STMTDLY"), "--prof-exec",
         "--prof-pgo", test.root + "/include/verilated_save.cpp"
     ],
diff --git a/test_regress/t/trace_lib_common.py b/test_regress/t/trace_lib_common.py
index fd61a8c83..785cf38cb 100644
--- a/test_regress/t/trace_lib_common.py
+++ b/test_regress/t/trace_lib_common.py
@@ -21,8 +21,6 @@ def run(test, *, verilator_flags2=()):
 
     verilator_common_flags = [
         "--cc",
-        "--trace-threads",
-        "1",
         f"--trace-{fmt}",
         "--trace-underscore",  # Should not trace __Vhandle
         "--trace-max-width",
diff --git a/verilator-config.cmake.in b/verilator-config.cmake.in
index 9636c97af..b3c5c859b 100644
--- a/verilator-config.cmake.in
+++ b/verilator-config.cmake.in
@@ -297,10 +297,6 @@ function(verilate TARGET)
         list(APPEND VERILATOR_ARGS --threads ${VERILATE_THREADS})
     endif()
 
-    if(VERILATE_TRACE_THREADS)
-        list(APPEND VERILATOR_ARGS --trace-threads ${VERILATE_TRACE_THREADS})
-    endif()
-
     if(VERILATE_COVERAGE)
         list(APPEND VERILATOR_ARGS --coverage)
     endif()