After Moore's Law: Where Speed Comes From Now

For fifty years, if you wanted a faster computer, you mostly just waited. Every couple of years, transistors got smaller, chips got denser, and software got faster without anyone touching a line of code. That free ride is over. Transistors are still shrinking, but the reliable, predictable doubling that defined an entire industry's planning cycle has broken down — and the gains that used to arrive automatically now have to be engineered deliberately, layer by layer, through architecture, packaging, and code.

This isn't a story about computing hitting a wall and stopping. It's a story about where speed comes from changing shape. Understanding that shift matters whether you're picking cloud instances, designing a product roadmap, or just trying to figure out why your new laptop doesn't feel dramatically faster than the one it replaced.

What Moore's Law Actually Said

Gordon Moore's 1965 observation was narrower than most people remember it. He noted that the number of components that could be economically packed onto an integrated circuit was doubling roughly every year (later revised to about every two years), driven by improvements in manufacturing. It was an observation about transistor density and cost, not a law of physics, and not directly a promise about speed.

The reason Moore's Law felt like a speed guarantee for decades is that it traveled alongside a companion principle: Dennard scaling. Robert Dennard and colleagues showed in 1974 that as transistors shrank, you could increase their density, speed, and switching frequency while keeping power density roughly constant. Put those two effects together and you got the golden era of computing: more transistors, running faster, without a proportional increase in heat or power draw. Clock speeds climbed year over year, and software got faster just by running on newer hardware.

Two Separate Trends, One Shared Ending

It helps to separate the two trends explicitly, because they broke down at different times and for different reasons:

Dennard scaling's collapse is why clock speeds plateaued around 3-4 GHz in the mid-2000s and stayed there — chipmakers could no longer crank frequency without cooking the chip. The industry's answer was multi-core processors: instead of one faster core, you got several cores running at a similar speed. That bought another decade of progress, but it shifted the burden onto software, which had to be rewritten to actually use those extra cores. A lot of code never was.

Why Transistor Scaling Is Running Out of Room

Moore's Law itself hasn't stopped so much as it has gotten expensive and physically strained. A few concrete forces are pushing back:

• Quantum effects at small scales. As transistor features shrink toward a few nanometers, the insulating layers meant to stop current from leaking become thin enough that electrons can tunnel through them anyway. That leakage wastes power and generates heat even when a transistor is supposedly "off."
• Heat density. Packing more switching elements into the same area means more heat generated per square millimeter. Removing that heat fast enough to avoid throttling performance is now a first-order design constraint, not an afterthought.
• Lithography cost. Each new process node requires more advanced (and more expensive) manufacturing equipment. Extreme ultraviolet lithography tools cost a substantial multiple of the previous generation's equipment, and only a handful of foundries in the world can run them at volume.
• Diminishing economic returns. Even when a smaller node is technically achievable, the cost per transistor doesn't always keep falling the way it used to. For some designs, moving to a newer node no longer makes financial sense.
• Design and verification complexity. Chips with tens of billions of transistors take enormous engineering effort to design, verify, and manufacture without defects, which lengthens development cycles and raises the cost of getting it wrong.

None of this means silicon scaling has stopped entirely — leading-edge nodes continue to ship — but the clean, predictable cadence that let entire industries plan around "wait 18 months, get double the performance" no longer holds. Speed now has to be found somewhere else.

Where Speed Comes From Now

If raw transistor scaling isn't enough on its own, where are the performance gains actually coming from? Mostly from four places, often layered together.

Specialized, Domain-Specific Hardware

The general-purpose CPU used to be the default engine for nearly every workload. Increasingly, it's the fallback for whatever doesn't have a purpose-built accelerator. Graphics processing units, originally designed for rendering images, turned out to be extremely good at the matrix multiplication that underlies both graphics and machine learning, which is why GPUs became central to AI training and inference. Beyond GPUs, companies now design application-specific integrated circuits (ASICs) and tensor-processing units tuned for narrow tasks — neural network inference, video encoding, cryptographic operations — that vastly outperform a general-purpose chip on that one job, at a fraction of the power draw.

The tradeoff is flexibility. A specialized chip is fast precisely because it throws away generality. That's a fine trade when the workload is predictable and large-scale (like data center AI inference), and a poor one when workloads are varied or short-lived.

Advanced Packaging and Chiplets

Instead of trying to shrink one monolithic piece of silicon further, chip designers increasingly build systems out of several smaller "chiplets" — separately manufactured dies, sometimes on different process nodes, connected through high-bandwidth interconnects and stacked or placed side by side in a single package. This approach lets a manufacturer use the most expensive, cutting-edge process only for the components that truly benefit from it (like compute cores), while using cheaper, mature processes for components like I/O controllers that don't need the latest node. It also improves manufacturing yield, since a single large chip has more area where a single defect can ruin the whole part, while smaller chiplets are individually easier to build correctly.

3D stacking — placing memory or cache directly on top of compute logic instead of beside it — is a related technique that shortens the physical distance data has to travel, cutting latency and power use for memory-bound workloads.

Software and Algorithmic Efficiency

When hardware gains slow down, the same performance improvement has to come from writing smarter code. This shows up in a few concrete ways:

1. Better algorithms. A more efficient algorithm can outperform years of hardware progress on the same problem; algorithmic improvements in areas like sparse computation and approximate methods have delivered order-of-magnitude gains in specific domains.
2. Compiler and runtime optimization. Modern compilers increasingly tailor code generation to specific hardware quirks — cache layouts, vector instruction sets, memory hierarchies — squeezing out performance that used to be left on the table.
3. Precision reduction. Many workloads, especially machine learning, don't need full 32-bit or 64-bit precision. Running computations in lower-precision formats trades a small amount of numerical accuracy for a large gain in throughput and energy efficiency.
4. Better parallelization. Software that's rewritten to actually exploit multiple cores, multiple chips, or distributed clusters can scale performance in ways a single faster core never could.

New Device Physics and Materials

Further out, researchers are exploring approaches that don't rely on shrinking a conventional silicon transistor at all. Photonic computing, which uses light instead of electricity to move and sometimes process data, promises much lower energy loss for data movement between chips. Novel transistor geometries — like gate-all-around designs that wrap the gate around the channel on all sides instead of just three — extend traditional scaling a bit further by improving control over current leakage. Neuromorphic chips, which mimic the event-driven, sparse activity pattern of biological neurons, aim to cut power consumption for certain AI workloads dramatically compared to conventional architectures. None of these are wholesale replacements for silicon transistors yet; they're additive tools being explored in parallel.

Why This Matters Right Now

For most of computing history, performance was something you could take for granted as a background tailwind. A team could ship inefficient code today, reasonably confident that next year's hardware would paper over the waste. That assumption is no longer safe. When transistor-driven speedups slow down, the gap has to be closed by architecture choices, packaging engineering, and — increasingly — the skill of the people writing software.

This shift is also reshaping who benefits from hardware progress. Under the old model, faster general-purpose chips lifted every workload roughly equally. Under the specialized-hardware model, the benefits are uneven: workloads that map well onto GPUs, ASICs, or other accelerators (large-scale AI training, certain scientific simulations, video processing) keep getting dramatically faster, while workloads that don't fit those patterns see much smaller gains and depend far more on manual software optimization. That unevenness is becoming a real strategic variable for anyone building products on top of computing infrastructure, not just a topic for chip designers.

Practical Implications for Businesses and Builders

The shift away from automatic hardware speedups changes how technical decisions should get made.

A few practical takeaways follow from that:

• Match the workload to the silicon. Before assuming you need more general-purpose compute, ask whether the workload — inference, encoding, search, simulation — has a specialized accelerator that fits it better. The performance and cost difference can be substantial.
• Treat software efficiency as a durable investment. Optimization work that used to be a nice-to-have, because hardware would eventually mask the cost of skipping it, now has a longer shelf life and a clearer return.
• Plan hardware refresh cycles around real workload gains, not habit. If a workload doesn't map well onto the newest accelerators, upgrading hardware on the old cadence may deliver much less benefit than it used to.
• Watch power and cooling as first-class constraints, not afterthoughts. As chips pack more into less space, power delivery and heat removal increasingly limit what's deployable, especially in dense data center environments.
• Expect more heterogeneous systems. Products that used to run on a single type of processor increasingly rely on a mix — CPU plus GPU plus specialized accelerator — which raises the complexity of both hardware selection and software design.

Limitations and Open Questions

None of the post-Moore approaches are clean substitutes for what transistor scaling used to provide automatically, and each comes with real constraints.

Specialized hardware only pays off at sufficient scale and workload predictability; designing and fabricating a custom ASIC is expensive and slow, which makes it a poor fit for workloads that change quickly or run at small volume. Chiplet-based packaging solves some yield and cost problems but introduces new ones around interconnect bandwidth, latency, and thermal management between dies that didn't exist in a single monolithic chip. Precision reduction and algorithmic shortcuts can improve throughput, but they trade away accuracy or generality, and not every workload can tolerate that tradeoff.

There's also a broader open question about how long even the current pace of progress across these fronts can be sustained. Each of the post-Moore techniques — packaging, specialization, software efficiency — has its own diminishing-returns curve, and none of them individually offers the multi-decade runway that transistor scaling once did. It's not yet clear whether stacking these techniques together will deliver a comparably long runway, or whether the industry is instead trading one long, smooth curve of progress for a series of shorter, harder-won gains that each require more engineering effort than the last.

Finally, the economics of leading-edge manufacturing are increasingly concentrated. A shrinking number of foundries can produce the most advanced chips, which raises questions about supply chain resilience and pricing power that didn't matter as much when progress felt more evenly distributed across the industry.

What to Watch Next

A few threads are worth tracking if you want a sense of where post-Moore performance gains are heading:

• Packaging standards. As chiplet designs from different vendors need to interoperate, industry standards for chip-to-chip interconnects will shape how mixed-vendor systems get built.
• Power efficiency, not just raw speed. As thermal and power limits become the binding constraint, expect benchmarks and marketing to shift further toward performance-per-watt rather than peak throughput alone.
• Software toolchains that target heterogeneous hardware. Compilers, runtimes, and frameworks that make it easier to target a mix of CPUs, GPUs, and accelerators without hand-tuning each workload will matter more as hardware diversity increases.
• Alternative computing paradigms maturing beyond the lab. Photonic interconnects and neuromorphic designs are still mostly research and niche deployments; watch for signs they're moving into mainstream production use for specific workloads.
• How memory keeps up. As compute gets faster and more specialized, moving data to and from memory increasingly becomes the bottleneck; advances in memory bandwidth and 3D integration will matter as much as compute itself.

FAQ

Is Moore's Law dead?

Not entirely — transistor density is still increasing at the leading edge of manufacturing — but the reliable, low-cost doubling that defined the original observation has slowed considerably and costs more per transistor to achieve than it used to. Most engineers now describe it as slowing and becoming economically strained rather than cleanly "ending" on a specific date.

What replaced Moore's Law as the main source of speed gains?

No single thing replaced it. Speed now comes from a combination of specialized hardware (GPUs, ASICs, TPUs), advanced chip packaging like chiplets and 3D stacking, and software-level efficiency gains such as better algorithms and lower-precision computation.

Why did clock speeds stop increasing years ago?

Clock speeds plateaued in the mid-2000s because Dennard scaling broke down — shrinking transistors further no longer kept power density constant, so pushing clock speeds higher generated more heat than could be practically removed. The industry shifted to adding more cores instead of running each core faster.

What are chiplets, and why do they matter?

Chiplets are smaller, separately manufactured pieces of silicon that are combined into a single chip package instead of building one large monolithic die. They improve manufacturing yield, let designers mix process nodes for cost efficiency, and are a major reason modern high-performance chips keep getting faster despite transistor scaling slowing down.

Does the end of easy Moore's Law gains mean AI progress will slow down?

Not directly. Much of recent AI hardware progress has come from specialized accelerators like GPUs and TPUs rather than general transistor scaling, so AI-specific hardware can keep improving even as general-purpose chip scaling slows. That said, AI workloads still depend on advances in packaging, memory bandwidth, and power efficiency to keep scaling.

Should businesses change how they plan hardware upgrades?

Yes, in the sense that assuming automatic performance gains from waiting for newer general-purpose hardware is less reliable than it used to be. It's worth evaluating whether a workload benefits from specialized accelerators and whether software optimization offers a better return than a hardware refresh.

What is Dennard scaling, and how is it different from Moore's Law?

Moore's Law is about transistor density — how many transistors fit on a chip. Dennard scaling is about power — the idea that as transistors shrink, power density stays roughly constant, letting chips run faster without overheating. Dennard scaling broke down in the mid-2000s, well before Moore's Law itself started slowing, and that breakdown is why clock speeds stalled while transistor counts kept climbing.

Teams navigating this shift — deciding where specialized hardware, better software, or infrastructure redesign will actually move the needle — can find hands-on help from Woyce Technologies.