SMT stands for simultaneous multithreading, a CPU design that lets a single processor core run two or more threads of instructions at the same time. Instead of leaving parts of the core idle while waiting on memory or other bottlenecks, SMT fills those gaps with work from another thread. Intel’s branded version of this technology is called Hyper-Threading, but the underlying concept is the same.
How SMT Works Inside a Core
A modern CPU core has many functional units: parts that handle math, parts that load data from memory, parts that make comparisons. During normal operation, a single thread of instructions rarely keeps all of these units busy at once. One instruction might be waiting for data to arrive from RAM while the arithmetic units sit idle. SMT solves this by giving each thread its own program counter, register file, and status tracking, while letting both threads share the core’s execution hardware. Instructions from all active threads get placed together into the same scheduling queues, and the core’s existing scheduling logic decides which instructions to run each clock cycle based on what resources are available.
This is different from older forms of multithreading where the core would switch entirely from one thread to another (for example, when the first thread stalled). With SMT, instructions from multiple threads can literally execute in the same clock cycle. The processor doesn’t need any special scheduling hardware to make this work. The same out-of-order execution logic that modern cores already use to reorder instructions within a single thread handles the mixing of instructions from multiple threads naturally.
Performance and Efficiency Gains
SMT doesn’t double your performance. Two threads sharing one core are competing for the same execution units, cache space, and memory bandwidth. In practice, SMT efficiency typically falls between 80% and 100% on well-threaded workloads, meaning two threads on one SMT core get roughly 1.6 to 2.0 times the throughput of a single thread. The exact gain depends heavily on the workload. Tasks that spend a lot of time waiting on memory see the biggest improvements because there are more idle gaps for the second thread to fill.
From a power perspective, the overhead of adding SMT to a core is roughly 38 to 46% more power consumption when both threads are active. That sounds like a lot, but compare it to the alternative: adding a second physical core costs around 71 to 93% more power. So SMT gives you a meaningful chunk of extra throughput for about half the power cost of a whole new core. For memory-heavy workloads in particular, SMT is the most energy-efficient way to increase throughput. For tasks that are purely compute-bound and fit well in cache, additional physical cores tend to win on both performance and efficiency.
Intel Hyper-Threading vs. AMD SMT
Intel introduced its Hyper-Threading Technology in 2002, and AMD adopted SMT with its Zen architecture in 2017. Both implementations follow the same core principle: duplicate the thread state (registers, program counter) while sharing execution resources. The architectural details differ between vendors in how resources are partitioned and scheduled, but from a user’s perspective, the result is the same. Your operating system sees twice as many “logical processors” as physical cores. A 6-core CPU with SMT shows up as 12 threads.
When SMT Hurts Performance
Not every workload benefits from SMT. Gaming is the most common scenario where disabling it can actually improve performance. Games tend to use a limited number of threads and are extremely sensitive to latency. When two threads share a core, they also share the core’s cache. If those threads need different data, they can evict each other’s cache entries, forcing slower trips to main memory. This cache thrashing increases latency and can cause stuttering in frame delivery. Even highly multithreaded games like Battlefield 1 have shown both higher average frame rates and smoother frame times with SMT disabled on some hardware.
There’s also a small scheduling overhead. The operating system has to manage more logical processors, and if an application doesn’t use enough threads to keep them all busy, that overhead can slightly reduce performance on the threads that are actually doing work.
Security Concerns With SMT
Because two threads on an SMT core share physical resources like caches and execution units, one thread can potentially spy on another. This is the basis of several high-profile CPU vulnerabilities. L1 Terminal Fault (L1TF) exploits the shared first-level data cache to infer secret data from another thread. The Spectre and Meltdown family of attacks exploit speculative execution, where the CPU guesses what instructions to run next and sometimes leaves traces of sensitive data that a malicious thread on the same core can detect.
For most desktop users, operating system patches and microcode updates have addressed these issues with minimal performance impact. But in server and cloud environments, where untrusted code from different customers might run on the same physical core, the risk is more serious. Some security-sensitive deployments disable SMT entirely as a precaution. Linux, for example, offers a kernel option that disables SMT specifically to mitigate L1TF.
Why Some New CPUs Drop SMT
Recent Intel designs have moved away from SMT on their efficiency cores. The reasoning is straightforward: a core without SMT is about 10% smaller in chip area and uses about 15% less power when running a single thread at the same performance level. For high-efficiency designs, that saved area can instead fit three small cores in the space that one large SMT-capable core would occupy, delivering far more total multithreaded performance.
For servers, where maximizing throughput per watt across many threads is the priority, SMT still makes sense and remains standard on performance cores. But in laptops and hybrid desktop processors, the math favors packing more small physical cores rather than making fewer cores wider with SMT. This is why modern Intel chips use a hybrid approach: performance cores with Hyper-Threading for single-threaded speed, and clusters of smaller efficiency cores without it for parallel workloads.