Found Fast, Selected Slow: The Substrate Behind Nvidia’s Two Exaptations

An extended edition of the Nvidia case for technical readers. It asks what the GPU had to be for two undesigned functions to become reachable, why both were first demonstrated within two years of each other, and why one waited almost a decade longer to be built into silicon. EGS Postdoc Case Study, extended edition.

By Shripal Shah, DBA — Founder, Exaptation AI

The Substack and LinkedIn versions of this case tells the story at the level of public breakthroughs. Researchers found two new functions in Nvidia’s graphics chips, and Nvidia adaptively shaped them after the discovery. Measured by those breakthroughs, the two functions are about ten years apart. Measured by their first traces in the research record, they appeared within about two years of each other. This edition is for readers who want to know why that gap opened, and why either function could happen at all.

Three claims run through the case:

• First, discovery was nearly simultaneous but selection was not, and each function reached Nvidia’s slow layers only after markets or public had visibly selected it.

• Second, both functions depended on the same move: rewriting a problem into the operation the hardware already did best.

• Third, what Nvidia could segment, and what the two functions now compete for in silicon, was dependent on what gaming needed.

For new readers: in biology, an exaptation is a trait that evolved for one purpose and later took on a different one. In business, it is the moment an existing asset or resource starts doing a valuable job it was never designed to do.

The Product Is Not the Substrate

A GeForce card is a product. Underneath the product is a substrate: the physical and logical properties the silicon has regardless of what it is sold for. For the GPU, those properties were shaped by the demands of rendering. Compared with a CPU, the chip spends more of its area on arithmetic units and less on the machinery that makes a single thread fast. It hides memory latency by keeping many threads in flight and switching among them. It is fed by memory with very high bandwidth. And it performs best when the same short program runs over a very large number of elements that rarely need to talk to each other.

CPUs prioritize low latency across varied control flow. GPUs generally prioritize throughput across many parallel threads. The two have grown more alike over time, with many-core CPUs on one side and caches and thread cooperation on the other, but the design emphasis differs. Rendering needed throughput, so the substrate became a throughput machine.

This distinction matters for exaptation because functions do not live in the substrate. Properties do. A function appears when an agent with a goal meets those properties in a particular context. Rendering was the function game developers brought. The same substrate could also serve other work with a similar shape: one operation, many largely independent elements, limited communication, and a lot of arithmetic for every byte moved. In our ongoing research on degrees of freedom, we have asked whether a base resource carries more degrees of freedom than the functions designed into the products built on it. The GPU is one of the clearest cases we have seen.

In a 2026 retrospective interview, Jensen Huang described Nvidia’s founding idea as accelerating problems a CPU handles poorly, with 3D graphics chosen as the first. That fits this reading. The company designed for acceleration and chose graphics as its first function. The functions that followed were first demonstrated largely by others.

What Games Paid For

Games did not just fund the GPU. They shaped it, and several changes they demanded widened what the substrate could do for someone else. Programmable shaders arrived with the GeForce 3 in 2001 so developers could write custom lighting and surface effects. Floating-point formats in the DirectX 9 generation of 2002 and 2003, which also served high dynamic range lighting in games, broadened the class of numerical problems researchers could try. They were not sufficient for everything. Many precision-sensitive simulations still had to wait for 64-bit arithmetic, which Nvidia first put in GPU hardware in 2008. Higher memory bandwidth and larger memory followed the demand for detailed textures.

A later pressure accelerated the spread. Around 2005, the long run of rising CPU clock speeds ended, as power density made faster single cores impractical. Herb Sutter’s 2005 essay, The Free Lunch Is Over, told programmers that more performance would have to come from parallelism. That did not cause the first discoveries, which came earlier. It did make the cheapest massively parallel machine on the market much more interesting to people who had not looked at it before.

The Theory of the Adjacent Possible (TAP) offers a useful qualitative lens. In the TAP equation studied by Cortês, Kauffman, Liddle, and Smolin, what can come next is limited by what already exists, and in many settings the count of new combinations sits on a long plateau before diverging sharply. GPU computing resembles that dynamic, although nothing here fits the equation to data. For roughly a decade it was a niche while its constituents accumulated: programmable shaders, floating point, a stream programming model, CUDA, cheap hardware in millions of homes, and large labeled datasets. When the last pieces arrived, the space of things a person could build on a GPU expanded very quickly.

EGS Postdoc Case Study · Nvidia · Extended · v1.1exaptationai.com

Found fast, selected slow

Both functions were first demonstrated within two years of each other, largely outside Nvidia. Each reached Nvidia’s slow layers only after visible selection.

Exaptation 1: general-purpose numerical computingExaptation 2: learning from dataEarly tracesPressureProduct trade-off

Exaptation 1: general-purpose numerical computing

1. 2002Research codeShader hacks; GPGPU named
2. 2004LibrariesBrook for GPUs
3. 2006SiliconG80 unified shaders
4. 2007Programming modelCUDA + PTX
5. 2008SiliconGT200: first FP64
6. 2010SiliconFermi: faster FP64, ECC

Exaptation 2: learning from data

1. 2003–11Research codeEarly ML on GPUs (first trace: 2003 patent filing)
2. 2012Research codeAlexNet (visible selection)
3. 2014LibrariescuDNN
4. 2016SiliconTesla P100 FP16
5. 2017SiliconV100 Tensor Cores

Pressure and product trade-offs

1. ~2005PhysicsCPU clock scaling stalls (accelerant)
2. 2025SiliconB300: FP64 down, FP4 up
3. 2026SiliconRubin: FP64 near H100 (preliminary)

Pace layers after Stewart Brand (1999), who described fast layers as the ones that learn and slow layers as the ones that remember. Rows are the GPU computing stack, from research code (fastest) to the physics of computation (slowest). Points mark first public release or filing. Illustrative, not exhaustive. The ~2005 CPU clock stall accelerated adoption and did not cause the first discoveries. FP64 trade-offs are product-specific, and Rubin figures were preliminary in 2026.

Exaptation 1: Rendering as a Disguise for Arithmetic

The first exaptation was a translation problem. Early GPGPU researchers did not discover that GPUs were fast. Everyone knew that. They discovered that a large class of numerical problems could be rewritten as rendering. A fragment program became the kernel. Input arrays were loaded as textures. The output array was the render target. Drawing one rectangle that covered the screen launched the computation over every element, and iterative methods ran by rendering back and forth between two textures, a technique known as ping-ponging.

The constraints were severe. A fragment program could write only to its own pixel, so there was no scatter. Precision was limited and differed by vendor. Reading results back over the bus was slow. That researchers accepted all of this shows how large the gap in price and performance had become. Mark Harris, then a Ph.D. student at the University of North Carolina, coined the name GPGPU in 2002. At Stanford, Ian Buck’s group released Brook for GPUs in 2004, a compiler that turned stream programs into graphics calls for both ATI and Nvidia hardware.

That last detail is easy to miss. The first exaptation happened to the GPU as a category, not to Nvidia in particular. What was particular to Nvidia was the design response. It hired Buck in 2004, and with John Nickolls, he built CUDA (Compute Unified Device Architecture). The G80 architecture in 2006 replaced separate vertex and pixel units with unified processors, added on-chip shared memory and scatter writes, and exposed all of it through a C-like language, with the CUDA toolkit broadly available in 2007. CUDA also compiled to PTX, a virtual instruction set that gave developers a forward-compatibility path, so well-maintained code could run on later generations without a hardware-specific rewrite. ATI shipped its own low-level compute interface, Close to Metal, in 2006. Nvidia kept investing in a single platform for much longer.

From the substrate’s point of view, Brook and CUDA did not add arithmetic. The arithmetic was already there. They lowered the cost of reaching it, from a researcher fluent in graphics interfaces to any programmer who knew C. Our working assumption from the degrees-of-freedom research is that designed flexibility mostly works this way: it makes function classes the substrate already supports reachable to more agents. Silicon followed in steps. GT200 in 2008 added Nvidia’s first hardware double precision, one 64-bit unit per multiprocessor, a feature reviewers at the time noted games would barely use. Fermi in 2010 extended it with much faster double precision, ECC memory, a full cache hierarchy, and IEEE 754-2008 floating point, particularly in its Tesla compute products. By November 2012, the Titan supercomputer at Oak Ridge National Laboratory, built on Nvidia GPUs, was ranked first in the world.

Exaptation 2: Found Early, Selected Late

The usual story dates the second function to AlexNet in 2012. Its first traces are almost as old as the first function’s. A Microsoft patent application with priority to December 2003, filed in the United States in April 2004 and in Europe that November, names David Steinkraus, Ian Buck, and Patrice Simard as inventors. It describes using pixel shaders to train the learnable parameters of a neural network. The same group published a two-layer network on a GPU in 2005, with a speedup of about three times over a contemporary CPU. Other early work appeared in the same years, including a 2004 journal paper on GPU neural networks by Kyoung-Su Oh and Keechul Jung and a 2004 chapter on neural networks for programmable graphics hardware in a game programming anthology.

Convolutional networks followed. In 2006, Kumar Chellapilla, Sidd Puri, and Patrice Simard sped up convolutional networks by unrolling each convolution into a matrix multiplication and running it on a GPU, the same reduction later adopted by frameworks such as Caffe. Rajat Raina, Anand Madhavan, and Andrew Ng reported large GPU speedups for deep belief networks in 2009. Dan Cireşan and colleagues trained large multilayer perceptrons on GPUs to record handwritten-digit results in 2010 and published flexible GPU convolutional networks in 2011.

So the second function was demonstrated, used, and retained in a small research community for about eight years before it propagated. AlexNet was the propagation event, and it mattered because of where it happened: in a public, well-attended selection arena, the 2012 ImageNet challenge, with 1.2 million labeled training images. At that scale the GPU stopped being a convenience and became a requirement. The network had about 60 million parameters and did not fit in the 3 GB of one GTX 580, so Krizhevsky split it across two cards and let them exchange data only at certain layers. That split, a form of model parallelism, began as a workaround for the memory limit of a gaming card.

Why did this function wait so long when the first one moved quickly? The first had buyers almost immediately: scientists who already paid for computing time and could use faster answers to equations they had already written. The second needed complements that did not yet exist. It needed datasets large enough to reward bigger networks, training methods that worked at that scale, a programming platform that made the experiments cheap, and a public arena where a result could not be ignored. Speedups of three times on a niche workload did not justify a product line in 2005. Discovery was not the bottleneck. Selection was.

There is a sharper detail in the products. Nvidia’s GeForce Fermi cards ran double precision at one-eighth of single-precision speed, against one-half on its Tesla compute cards. Asked about it on Nvidia’s developer forum in 2010, an Nvidia representative said full-speed double precision was reserved for professional customers, since consumer applications had little use for it. That segmentation protected the first function’s market. Neural network training needed single precision, the format games depended on at full speed, so the second function arrived through capacity that had no reason to be limited on a gaming card.

Inside Nvidia, the function was known before it was legible as a business. Buck, a named inventor on the 2003 filing, went on to create CUDA at Nvidia. Bryan Catanzaro has described spending years trying to interest colleagues in deep learning before Jensen Huang began paying close attention in 2013. One possible reading is functional fixedness, Karl Duncker’s term for seeing an object only in its familiar role. A more charitable and probably more accurate reading is that the difficulty was estimating a market that did not yet exist.

Sara Hooker’s essay on the hardware lottery suggests a reverse view. Research directions that fit the available hardware and software can gain an advantage that has little to do with their intrinsic merit, and deep learning’s dense linear algebra may have benefited from exactly that. If so, the substrate did not only host the new function. It may also have helped select which kind of AI became the function.

Where One Function Ends and the Next Begins

A skeptical engineer will ask whether learning from data is a new function at all, or just one more program running on a general-purpose processor. The physical operation is the same in all three cases: multiply, add, repeat. In Exaptation Growth Strategy, though, a function is defined by what a resource does in relation to an agent and a context, not by the instruction it executes. Read at that level, the GPU climbed a ladder.

In rendering, it computed what each pixel should look like for a viewer, and the agents were game developers and players. In general-purpose computing, it computed answers to equations that scientists had written, and the buyers were research labs and supercomputing centers. In learning from data, it adjusted millions of parameters until a model fit its examples, and the output was a program nobody wrote. The agents were machine learning researchers, the selection arena was a public benchmark, and the stabilized products were libraries and chips built for training.

The 2003 filing already described the job that way, as training learnable parameters, which suggests its inventors saw it as a distinct use and not one more numerical routine. It is an analytical choice on where to draw the boundary. A strict reading would class 2012 as a very large new application of general-purpose computing. We read it as a second function, because the relationship among the resource, its users, and its output changed beyond its original designed function, and so did the market that selected it.

Found Fast, Selected Slow

Stewart Brand described civilization as a stack of pace layers, from fast-moving fashion down through commerce, infrastructure, governance, and culture to nature, the slowest. In his account, fast layers are where a system learns and slow layers are where it remembers. The computing stack has a similar structure. Research code and models change in weeks. Libraries and frameworks change over months to years. A programming model like CUDA stays stable for decades. Silicon architecture is set once per generation and inherited by the generations after it. Beneath all of it sit the physical limits of computation.

Both functions moved down this stack in the same order, but on different clocks (see image above). The first was demonstrated in shader code in 2002, packaged in Brook in 2004, turned into a programming model with CUDA in 2006 and 2007, and built into silicon in steps: G80 in 2006, double precision in GT200 in 2008, and Fermi in 2010. The second was first demonstrated in 2003 and 2004 but waited until its 2012 breakthrough to move. Nvidia then packaged it as the cuDNN library in 2014 and built for it in the Tesla P100 in 2016, with fast half precision, and in the V100 in 2017, with Tensor Cores.

The interval that looks consistent is not from discovery to silicon. It is from visible selection to silicon. For the second function that was about four to five years, part of which is simply chip design lead time. For the first, selection was more gradual, as a research community and then a paying scientific market formed around it.

Two things follow. First, a firm’s earliest evidence of its own next exaptation sits in the layer it watches least: other people’s code, papers, patents, and forum threads. Nvidia’s signal for the second function was in the research record, including a patent co-invented by the future creator of CUDA, years before it was on the roadmap. Second, the slow layers are what made the fast-layer search cheap. Because CUDA kept a forward-compatibility path through PTX, researchers could keep much of their code working across hardware generations, and the edge could keep experimenting without starting over every two years. Stability at the bottom helped pay for exploration at the top.

What Nvidia Could Segment

Nvidia has segmented emergent uses of its gaming cards several times, with different tools. The reduced double-precision rate on GeForce cards is one. The public record does not say exactly how it was implemented, only that it held. In late 2017, Nvidia changed the GeForce driver license so that the software was not licensed for data center deployment, with an exception for blockchain processing, while saying it did not intend to stop researchers from adapting the cards for non-commercial research. In 2021, when Ethereum mining drew GeForce cards away from gamers, Nvidia’s drivers recognized the Ethereum mining algorithm and cut its hash rate by about half on targeted models, and the company launched a separate mining product line. That limiter was later partly bypassed.

Our working hypothesis from these episodes is about the cost of segmentation. A blanket limit on a capability the original function needs, such as single-precision throughput on a gaming card, would hurt the product’s main customers. Narrower tools, such as workload detection in drivers, product features, and license terms, can segment uses at lower cost, and in these cases they left the research edge open. This is a hypothesis drawn from one company’s history, not an established rule.

There is a further twist. Both functions eventually flowed back into games. After Nvidia acquired Ageia in 2008, its PhysX physics engine ran on CUDA in games. In 2018, the Turing generation brought Tensor Cores to GeForce cards, and its DLSS feature began using neural networks to upscale game images. From then on, any fence around AI on a gaming card would also cut into gaming.

When Two Functions Compete for the Same Silicon

A resource that carries more than one function eventually faces trade-offs among them, and biologists see a similar pattern in structures that serve several roles. Nvidia’s two functions pull precision in opposite directions. Scientific computing needs 64-bit floating point and error-corrected memory. AI computing, first training and now increasingly inference, has pushed down to 16-bit, 8-bit, and 4-bit formats.

Nvidia has managed the tension product by product, not in one direction. Per GPU in its HGX systems, conventional FP64 throughput is about 37 teraflops on the B200 and about 1.25 on the B300, which traded it for more 4-bit throughput aimed largely at inference. The H100 SXM delivers about 34 teraflops of conventional FP64, or 67 using its FP64 Tensor Cores. Nvidia’s preliminary figure for Rubin is about 33 teraflops of native FP64, close to the H100.

Part of Nvidia’s answer is emulation. Recent cuBLAS releases can run selected FP64 matrix multiplications on INT8 Tensor Cores using the Ozaki scheme, a numerical method first published in 2012, with automatic fallback to native execution. Nvidia cites up to 200 teraflops of emulated FP64 matrix throughput for Rubin. AMD and others caution that emulation can struggle on ill-conditioned problems and vector-heavy codes. Within those limits, part of the first function now runs, by emulation, on hardware shaped by the second.

The Search Was Shaped Like the Substrate

Who found these functions matters as much as what they found. Both were first demonstrated by many independent and partially connected research groups, each running small experiments on cheap hardware with freely available tools, rewarded for publishing speedups and winning benchmarks. In that sense the search for the GPU’s new functions resembled the workload it discovered: many small searches running at once, covering more of the function space than any single roadmap could. Nvidia helped seed that population. From the start of CUDA it ran outreach to universities, and Catanzaro has said his own path to the company began with that outreach.

Our research on network topology points to a working hypothesis that discovery and propagation favor different structures. Discovery seems to favor many loosely coordinated searchers, while propagation needs a point where the discovery is consolidated and made reliable. In this case the research community discovered and Nvidia consolidated, with CUDA for the first function and cuDNN for the second. We have not yet tested this against collaboration or adoption network data.

Stuart Kauffman has argued that the uses of an object cannot be exhaustively listed in advance, because they depend on the goals and contexts of agents that do not yet exist. In 2001, people could already imagine some non-graphics uses for shaders. No one could have enumerated the functions and markets programmable shaders would later support. A firm cannot plan the function. It can plan the conditions under which others find one: a substrate that is reachable, cheap enough to experiment on, stable at the slow layers, and watched closely at the fast ones.

The Causes, Side by Side

	Exaptation 1: general-purpose numerical computing	Exaptation 2: learning from data
First traces	2002: GPGPU named at UNC	2003–2004: Microsoft patent filing, early GPU neural networks
Visible selection	Gradual: a research community (2002–2005), then scientific buyers	AlexNet wins the 2012 ImageNet challenge
Substrate property recruited	The same short program over many independent elements, with high memory bandwidth	Dense matrix multiplication at high arithmetic intensity, in single precision
Upgrade the original market paid for	Programmable shaders (2001), DirectX 9-era floating point (2002–2003)	Full-speed single precision and growing memory on consumer cards
Pressure from outside	Demand for cheaper scientific computing, accelerated after CPU clock scaling stalled (~2005)	Large labeled datasets (ImageNet, 1.2 million images) and a public challenge
Translation layer	Graphics interfaces, then Brook (2004), then CUDA (2006–2007)	Convolution unrolled into matrix multiplication (2006), CUDA, then cuDNN (2014)
Who searched	Graphics and scientific computing researchers	Machine learning researchers, 2003–2011
Built into Nvidia silicon	G80 (2006), GT200 double precision (2008), Fermi (2010)	Tesla P100 half precision (2016), V100 Tensor Cores (2017)
Segmented on GeForce?	Yes: reduced double-precision rate	Not by a blanket single-precision limit. Data center deployment addressed in the driver license (2017)
Flowed back into games?	Yes: GPU-accelerated PhysX on CUDA (2008)	Yes: Tensor Cores and DLSS on GeForce (2018)

One Path, Not an Average

Ergodicity economics adds one more observation: Ole Peters distinguishes the average outcome across many possible firms from the outcome one firm experiences over time along a single path. Judged as an average across firms, a bet on general-purpose GPU computing in 2006 looked poor, and Catanzaro has said it made every Nvidia product more expensive.

Nvidia did not live the average. It lived one path, and on that path the requirement was to keep the bet alive through a long plateau. The first function paid for that. Gaming revenue carried the cost of CUDA for years before the second exaptation turned it into a market.

Questions for the People Who Built It

We wrote this as outsiders reading a history that others lived, and we would like to know where this reading is wrong. A few questions the public record cannot answer: Which substrate properties were kept general on purpose, for reasons other than graphics? How was the GeForce double-precision limit decided, and was it seen as protecting a function or a price point? Why did a 2003 filing on training neural networks with shaders not become an Nvidia program sooner? And what is in today’s fastest layer that will be in silicon five years from now?

At Exaptation AI, we are building the search engine for every asset’s undiscovered functions. Growth, in our view, is a search problem, and the GPU is one of the most valuable examples of exaptation that is likely hiding more emergent functions awaiting discovery.

Sources

Brand, S. (1999). The Clock of the Long Now: Time and Responsibility. Basic Books.

Buck, I., Foley, T., Horn, D., Sugerman, J., Fatahalian, K., Houston, M., & Hanrahan, P. (2004). Brook for GPUs: Stream computing on graphics hardware. ACM Transactions on Graphics, 23(3) (SIGGRAPH 2004). https://graphics.stanford.edu/papers/brookgpu/

Chellapilla, K., Puri, S., & Simard, P. (2006). High performance convolutional neural networks for document processing. Tenth International Workshop on Frontiers in Handwriting Recognition.

Chetlur, S., Woolley, C., Vandermersch, P., Cohen, J., Tran, J., Catanzaro, B., & Shelhamer, E. (2014). cuDNN: Efficient primitives for deep learning. arXiv:1410.0759.

Cireşan, D. C., Meier, U., Gambardella, L. M., & Schmidhuber, J. (2010). Deep, big, simple neural nets for handwritten digit recognition. Neural Computation, 22(12). https://arxiv.org/pdf/1003.0358

Cireşan, D. C., Meier, U., Masci, J., Gambardella, L. M., & Schmidhuber, J. (2011). Flexible, high performance convolutional neural networks for image classification. Proceedings of IJCAI 2011.

Cortês, M., Kauffman, S. A., Liddle, A. R., & Smolin, L. (2025). The TAP equation: Evaluating combinatorial innovation. European Economic Review, 179, 105144. https://doi.org/10.1016/j.euroecorev.2025.105144

DatacenterDynamics (2018). Nvidia updates GeForce EULA to prohibit data center use. https://www.datacenterdynamics.com/en/news/nvidia-updates-geforce-eula-to-prohibit-data-center-use/

Duncker, K. (1945). On problem-solving. Psychological Monographs, 58(5).

Fast Company (2023). How Bryan Catanzaro jump-started Nvidia’s AI Big Bang. https://www.fastcompany.com/90957372/how-bryan-catanzaro-jumpstarted-nvidias-ai-big-bang

Harris, M. J., Coombe, G., Scheuermann, T., & Lastra, A. (2002). Physically-based visual simulation on graphics hardware. Proceedings of the SIGGRAPH/Eurographics Workshop on Graphics Hardware 2002.

Hooker, S. (2021). The hardware lottery. Communications of the ACM, 64(12).

HPCwire (2025, December 9). Nvidia says it’s not abandoning 64-bit computing. https://www.hpcwire.com/2025/12/09/nvidia-says-its-not-abandoning-64-bit-computing/

HPCwire (2026, August 3). AMD’s FP64 boost with MI430X is even bigger than expected. https://hpcwire.com/2026/08/03/amds-fp64-boost-with-mi430x-is-even-bigger-than-expected

Kauffman, S. A. (2000). Investigations. Oxford University Press.

Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. Advances in Neural Information Processing Systems 25.

Lambert, N. (2025). Why Nvidia builds open models with Bryan Catanzaro. Interconnects. https://www.interconnects.ai/p/why-nvidia-builds-open-models-with

Lindholm, E., Nickolls, J., Oberman, S., & Montrym, J. (2008). NVIDIA Tesla: A unified graphics and computing architecture. IEEE Micro, 28(2).

Lockwood, G. K. B300 (Blackwell Ultra). https://glennklockwood.com/garden/processors/B300

NVIDIA (2008). GeForce GTX 200 GPU technical brief. https://nvidia.com/docs/io/55506/geforce_gtx_200_gpu_technical_brief.pdf

NVIDIA (2009). Fermi compute architecture white paper. https://www.nvidia.com/content/pdf/fermi_white_papers/nvidia_fermi_compute_architecture_whitepaper.pdf

NVIDIA (2016). Inside Pascal: NVIDIA’s newest computing platform (Tesla P100). https://developer.nvidia.com/blog/inside-pascal/

NVIDIA (2017). NVIDIA launches revolutionary Volta GPU platform. https://nvidianews.nvidia.com/news/nvidia-launches-revolutionary-volta-gpu-platform-fueling-next-era-of-ai-and-high-performance-computing

NVIDIA (2025). Unlocking Tensor Core performance with floating point emulation in cuBLAS. https://developer.nvidia.com/blog/unlocking-tensor-core-performance-with-floating-point-emulation-in-cublas/

NVIDIA. CUDA Programming Guide: CUDA platform and PTX compatibility. https://docs.nvidia.com/cuda/cuda-programming-guide/01-introduction/cuda-platform.html

NVIDIA Developer Forums (2010). GTX 480/470 double precision reduced? https://forums.developer.nvidia.com/t/gtx-480-470-double-precision-reduced/15752

Oh, K.-S., & Jung, K. (2004). GPU implementation of neural networks. Pattern Recognition, 37(6).

Owens, J. D., et al. (2007). A survey of general-purpose computation on graphics hardware. Computer Graphics Forum, 26(1).

Raina, R., Madhavan, A., & Ng, A. Y. (2009). Large-scale deep unsupervised learning using graphics processors. Proceedings of ICML 2009.

Rolfes, T. (2004). Artificial neural networks on programmable graphics hardware. In Game Programming Gems 4. Charles River Media.

Smith, R. (2021, May 18). NVIDIA to extend Ethereum throttle to GeForce RTX 3080, 3070, and 3060 Ti “LHR” cards. AnandTech. https://www.anandtech.com/show/16690

Steinkraus, D., Buck, I., & Simard, P. Y. (2005). Using GPUs for machine learning algorithms. Proceedings of ICDAR 2005. https://doi.org/10.1109/ICDAR.2005.251

Steinkraus, D. W., Buck, I. A., & Simard, P. Y. System and method for accelerating and optimizing the processing of machine learning techniques using a graphics processing unit. US Patent 7,219,085 (application filed April 30, 2004) and European Patent Application EP 1 569 128 (filed November 4, 2004), priority US 60/528,578 (December 9, 2003). Applicant: Microsoft Corporation.

Sutter, H. (2005). The free lunch is over: A fundamental turn toward concurrency in software. Dr. Dobb’s Journal, 30(3).

The Register (2018, January 3). Nvidia: Using cheap GeForce, Titan GPUs in servers? https://www.theregister.com/2018/01/03/nvidia_server_gpus/

The Register (2026, January 18). Nvidia leans on emulation to squeeze more HPC oomph from AI chips. https://www.theregister.com/2026/01/18/nvidia_fp64_emulation/

TOP500 (2012). Titan, Oak Ridge National Laboratory. https://www.top500.org/resources/top-systems/titan-oak-ridge-national-laboratory/

Y Combinator (2026). Jensen Huang: The mindset that built NVIDIA (Startup School interview). https://www.ycombinator.com/library/Tq-jensen-huang-the-mindset-that-built-nvidia

Shah, S. (2024). Exaptation Growth Strategy. Doctor of Business Administration dissertation, Pepperdine Graziadio Business School.