Jensen is out. CUDA isn't. A Developer's Guide to Everything Nvidia Built

Yesterday, Jensen Huang resigned as Nvidia's CEO, effective immediately. The stock fell as much as 14% during the day before closing down 4.3%.

If you write code for a living, the stock drop is not the interesting part. The interesting part is that a single company, run by a single founder for 33 years, ended up owning the layer that almost every AI workload runs on. Your PyTorch training loop, your vLLM server and the model behind your coding assistant all sit on that layer.

So this post skips most of the boardroom drama and asks the developer questions. What did Nvidia actually invent? Why is CUDA so hard to leave? And does any of it change now that Huang is gone?

TL;DR

• What happened: Huang resigned as president, CEO and director on November 12, 2026. CFO Colette Kress is interim CEO, and Harvey C. Jones became Nvidia's first board chair. Nvidia gave no reason.
• For developers, nothing changes this week. CUDA, cuDNN, NCCL, TensorRT and the Nemotron models keep shipping. Nvidia credits over 6 million developers with building on CUDA.
• The key invention was making the GPU programmable: programmable shaders in 2001, then CUDA in 2006, put on every GeForce card, including cheap ones. That is why a grad student's gaming PC could train AlexNet in 2012.
• The moat is software, not silicon. A rival chip has to replace compilers, PTX, libraries, profilers and framework support, not just match FLOPS.
• Huang was one of open source's strongest allies in big tech. He agreed to buy Hugging Face for $12.93 billion, co-wrote an industry letter defending open-weight models, and called DeepSeek-R1 "genuinely a gift to the world's AI industry." I counted 338 Nvidia engineers in the git history of open-source AI projects over the last 12 months, including DeepSeek's own kernel libraries.
• Gaming paid for AI. Data center was $193.7B, about 90% of Nvidia's $215.9B in fiscal 2026 revenue. Gaming, the original business, was $16.0B.
• You can research all of this with code. Every research example comes in two flavors: a fast Search call and a cited DeepResearch report, in JavaScript and Python.

Contents

1. What actually happened
2. Era 1: Graphics, and the chip that became programmable
3. Era 2: CUDA, explained with code
4. Era 3: AI factories
5. Why the moat is software
6. How gaming paid for AI
7. Seven times Nvidia nearly failed
8. The engineers behind the moat
9. Jensen and open source: 338 engineers, counted
10. Follow the money: who owns Nvidia, and who Nvidia owns
11. Research Nvidia yourself, with code
12. What changes for developers
13. FAQ

What actually happened

Nvidia's board announced that Huang had resigned as president, CEO and director. It is the company's first CEO change since he co-founded it in 1993.

• Interim CEO: Colette Kress, CFO since 2013. She keeps the CFO job too.
• Board chair: Harvey C. Jones, the former Synopsys CEO, who has been on the board since 1993. Nvidia never had a chair before.
• Reason: The release gives none. Press reports link the exit to a board review of Huang's personal conduct. Nvidia has not confirmed them, and its 8-K does not mention them.
• Market: Shares closed down 4.34% at $166.19, about 30% below the October 6 record close.

That's the news. Now the engineering.

Era 1: Graphics, and the chip that became programmable

1993. Huang, Chris Malachowsky and Curtis Priem founded Nvidia to build 3D graphics chips for PCs.

1995: NV1, the wrong bet. NV1 rendered 3D with quadratic surfaces instead of the triangles the rest of the industry was standardizing on through Direct3D. Clever, and commercially wrong. Nvidia nearly died.

1997: RIVA 128, shipped without a prototype. Nvidia switched to triangles. With about six months of cash left, by Huang's account, it verified the RIVA 128 on a hardware emulator and sent the design straight to mass production. Huang has said he never held the chip before ordering it. If you've ever shipped to prod without a staging environment, imagine doing it with the whole company.

1999: GeForce 256 and the word "GPU." Nvidia marketed it as the world's first GPU. The real leap was hardware transform and lighting: moving per-vertex geometry math off the CPU. "First GPU" is Nvidia's label, and rivals dispute it, but the name stuck.

2001: GeForce 3 and programmable shaders. This is the one that matters for AI. Before GeForce 3, graphics chips ran a fixed pipeline. GeForce 3 let you write small programs, vertex shaders and pixel shaders, that ran for every vertex or pixel.

Once the hardware ran programs, researchers started abusing it for non-graphics math: encode your data as a texture, write a "shader" that's really a linear algebra kernel, read the result back as pixels. The hack got a name, GPGPU, and it was painful enough that someone had to build a real programming model.

2004: SLI. Two graphics cards sharing one game's rendering. A footnote now, but it was Nvidia's first product built on the idea that linking GPUs together is a feature. That idea comes back as NVLink.

Era 2: CUDA, explained with code

2006: G80 and CUDA. The GeForce 8800 (G80) replaced separate vertex and pixel units with unified shader cores that could run any program. With it, Nvidia announced CUDA: write GPU code in ordinary C, no texture tricks. The first public release followed in 2007. It was built by Ian Buck, who had created the Brook stream language for his Stanford PhD, and John Nickolls, who led the GPU computing architecture.

Twenty years later, the core ideas haven't changed.

The mental model

• SIMT (single instruction, multiple threads). You write scalar code for one thread. The hardware runs it across thousands of threads in groups of 32 called warps.
• A thread hierarchy. Threads form blocks, blocks form a grid. Blocks get scheduled onto streaming multiprocessors (SMs), so the same code scales from a laptop GPU to a data-center GPU with well over a hundred SMs.
• An explicit memory hierarchy. Per-thread registers, fast per-block shared memory, and big but slow global memory. Most GPU performance work is moving data to the fast levels and keeping it there.
• PTX, a virtual ISA. CUDA compiles to PTX, and the driver compiles PTX to each GPU's real instructions.

Hello world: one thread per element

__global__ void add(const float* a, const float* b, float* c, int n) { int i = blockIdx.x * blockDim.x + threadIdx.x; // this thread's global index if (i < n) c[i] = a[i] + b[i]; } // launch enough 256-thread blocks to cover n elements add<<<(n + 255) / 256, 256>>>(a, b, c, n); 

No loop. You describe what one thread does, and the launch configuration <<<blocks, threadsPerBlock>>> decides how many run.

Where it gets interesting: shared memory

The naive matrix multiply reads every element of A and B from global memory N times. The classic fix is tiling: each block loads a small tile of A and B into shared memory once, and every thread in the block reuses it.

#define TILE 16 __global__ void matmul(const float* A, const float* B, float* C, int N) { __shared__ float As[TILE][TILE]; __shared__ float Bs[TILE][TILE]; int row = blockIdx.y * TILE + threadIdx.y; int col = blockIdx.x * TILE + threadIdx.x; float acc = 0.0f; for (int t = 0; t < (N + TILE - 1) / TILE; ++t) { int aCol = t * TILE + threadIdx.x; int bRow = t * TILE + threadIdx.y; As[threadIdx.y][threadIdx.x] = (row < N && aCol < N) ? A[row * N + aCol] : 0.0f; Bs[threadIdx.y][threadIdx.x] = (bRow < N && col < N) ? B[bRow * N + col] : 0.0f; __syncthreads(); // wait until the whole tile is loaded for (int k = 0; k < TILE; ++k) acc += As[threadIdx.y][k] * Bs[k][threadIdx.x]; __syncthreads(); // wait before overwriting the tile } if (row < N && col < N) C[row * N + col] = acc; } // dim3 block(TILE, TILE); // dim3 grid((N + TILE - 1) / TILE, (N + TILE - 1) / TILE); // matmul<<<grid, block>>>(A, B, C, N); 

Each global value is now loaded N / TILE times instead of N times, a 16x cut in global-memory reads for this tile size. Production libraries like cuBLAS and CUTLASS go much further (register tiling, async copies, Tensor Cores), which is exactly why almost nobody writes their own matmul. That gap between "correct kernel" and "fast kernel" is a big part of the moat.

PTX: why your old binaries still run

When you compile with nvcc, you can embed PTX alongside machine code for a specific GPU:

nvcc -gencode arch=compute_70,code=sm_70 \ -gencode arch=compute_70,code=compute_70 \ kernel.cu -o app 

code=sm_70 is native machine code for Volta. code=compute_70 embeds the PTX itself, which the driver can JIT-compile for GPUs that didn't exist when you built the binary. Nearly two decades of forward compatibility is one of the most underrated reasons teams stay on CUDA.

The business decision behind the code

The API wasn't the bold part. Putting CUDA on every GeForce card was. It cost die area and margin on products whose buyers just wanted to play games, and Wall Street questioned it for years. But it meant every student with a gaming PC owned a parallel computer they could program.

2010: Fermi added ECC memory, a real L1/L2 cache hierarchy and much faster FP64, which made GPUs acceptable to supercomputer centers.

2012: AlexNet. Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton trained a deep CNN on two GeForce GTX 580 gaming cards and won ImageNet with about 15% top-5 error against roughly 26% for the runner-up. Deep learning had been waiting for cheap parallel compute. CUDA on gaming GPUs supplied it.

2014: cuDNN. Nvidia packaged hand-tuned convolutions, pooling and activations into a library, and every framework adopted it. That became the pattern: find the hot loop in a new field, write the fastest library for it, and give it away to sell hardware.

2016: P100, NVLink, DGX-1. HBM2 memory, the first NVLink (a GPU-to-GPU link far faster than PCIe) and an eight-GPU "AI supercomputer in a box." Huang hand-delivered the first DGX-1 to a small non-profit called OpenAI.

Era 3: AI factories

2017: Volta and Tensor Cores. Neural nets spend most of their time multiplying matrices. Tensor Cores do a small matrix multiply-accumulate (a 4x4 block in the first generation) in mixed precision every clock. Every Nvidia data-center GPU since has them.

2018: Turing, RT cores and DLSS. Real-time ray tracing for games, plus DLSS: render at lower resolution, upscale with a neural network on the Tensor Cores. AI sold gaming, and gaming funded AI.

2020: A100 and Mellanox. Multi-Instance GPU slices one A100 into up to seven isolated GPUs. Nvidia also closed its $6.9B purchase of Mellanox, the InfiniBand leader. Training a large model is as much a networking problem as a compute problem, and Nvidia now owned both.

2021: Grace. An Arm-based data-center CPU built to feed GPUs over NVLink-C2C. (Nvidia doesn't make gaming CPUs; your gaming PC's CPU is Intel or AMD.)

2022: H100 and the Transformer Engine. It switches parts of a transformer to FP8 and back where accuracy needs it, roughly doubling effective throughput on the workload that was about to take over. Nvidia announced it in March 2022, eight months before ChatGPT launched.

2024: Blackwell and GB200 NVL72. Two dies acting as one GPU (208 billion transistors), FP4 support, and a liquid-cooled rack of 36 Grace CPUs and 72 Blackwell GPUs joined by NVLink switches at 130 TB/s, behaving like one giant GPU. The unit of compute became the rack.

2023 to 2026: Inference software and open models. TensorRT-LLM for fast LLM inference, Dynamo for spreading inference across GPUs, NIM containers for deployment, and the Nemotron 3 open models (December 2025) with a hybrid mixture-of-experts design and open training data. Reports put Nvidia's open-model commitment at roughly $26 billion over five years. Same playbook as cuDNN: make the best free software for your hardware.

Next: Nvidia says Vera Rubin is in production with partner systems from the second half of 2026, Rubin Ultra in 2027 and Feynman in 2028. Those are company plans, and details keep shifting.

Why the moat is software

AMD's MI-series GPUs, Google's TPUs, Amazon's Trainium and plenty of startups all post strong benchmark numbers. Raw FLOPS isn't the problem. Everything above the chip is.

• Libraries: cuBLAS, cuDNN, NCCL (the collective-communication library that lets thousands of GPUs average gradients), CUTLASS, cuFFT, RAPIDS.
• Tools: nvcc, PTX, and the Nsight Systems and Nsight Compute profilers you open when a kernel is mysteriously slow.
• Frameworks: PyTorch, vLLM and SGLang treat CUDA as their primary backend, and other chips usually get support later. Even JAX, built for Google's TPUs, runs on Nvidia GPUs through CUDA.
• People: at GTC 2026, marking 20 years of CUDA, Nvidia credited over 6 million developers.

You feel this in one line of PyTorch:

import torch device = "cuda" if torch.cuda.is_available() else "cpu" model = torch.nn.Linear(1024, 1024).to(device) 

The device string is literally "cuda". A rival doesn't have to beat a chip. It has to make that line, and the millions of kernels, configs and tutorials behind it, work on day one.

How gaming paid for AI

Nvidia didn't pivot from gaming to AI. Gaming funded AI for about 15 years.

1. Gamers bought GeForce cards in the tens of millions.
2. Those profits funded GPU R&D.
3. CUDA turned every card into a programmable parallel computer.
4. Researchers used cheap gaming GPUs, and AlexNet proved the approach.
5. TensorFlow and PyTorch were built CUDA-first because that's where the researchers were.
6. AI labs bought data-center GPUs by the rack, funding the next generation.

Source: Nvidia 10-K filings. Fiscal 2026 ended January 25, 2026.

Gaming didn't shrink. It grew 41% in fiscal 2026. Data center just grew far faster, and networking alone passed $31 billion.

Seven times Nvidia nearly failed

Nvidia's history looks like a straight line up only in hindsight. Early backer Mark Stevens has said that "between 1993 and 1997 we almost went bankrupt three times".

1. 1995, NV1 flops. Huang asked Sega to drop Nvidia's console contract but turn the rest into an investment. That $5 million kept Nvidia alive.
2. 1997, RIVA 128. Months of cash, an emulator instead of prototypes, and a hit.
3. 2002 to 2003, Xbox. A pricing fight with Microsoft went to arbitration. The next Xbox went to ATI, and the Xbox had been 15% to 20% of sales.
4. 2008, "bumpgate." A packaging flaw killed laptop GPUs. The stock fell 31% in a day, and Nvidia took a $196M charge.
5. 2018, crypto hangover. Mining demand vanished and the stock fell 18.8% in a day.
6. 2022, Arm deal dies. Regulatory opposition in the US, UK and EU sank the $40B deal. Nvidia took a $1.36B charge and built its own Arm CPU anyway.
7. 2025 to 2026, China. Export rules shut Nvidia out of China's data centers, with a $4.5B H20 charge.

The pattern: cut losses on the committed path, keep investing in the next architecture.

I didn't build this list by hand. You can reproduce it two ways with Valyu. Install the SDK first: npm install valyu-js (or pip install valyu for Python).

Search returns ranked sources in seconds, for about $0.003 a call. Good for checking one fact:

import { Valyu } from "valyu-js"; const valyu = new Valyu(process.env.VALYU_API_KEY); const res = await valyu.search( "NVIDIA near bankruptcy history NV1 Sega investment RIVA 128", { maxNumResults: 5 } ); for (const r of res.results) { console.log(r.title, r.url); } 

DeepResearch reads dozens of sources and writes the report for you. This list started as a Valyu DeepResearch report: one API call, 36 sources (SEC filings, Huang's interviews, news archives back to 2002), a cited report in under five minutes for about $0.16. I then checked every figure against its source:

import { Valyu } from "valyu-js"; const valyu = new Valyu(process.env.VALYU_API_KEY); const task = await valyu.deepresearch.create({ query: "Every time NVIDIA nearly failed, from its 1993 founding to 2026: " + "what happened, what decision saved it, and the outcome. Cite primary sources.", mode: "fast", // instant | fast | standard | heavy | max }); const report = await valyu.deepresearch.wait(task.deepresearch_id); console.log(report.output); // markdown report with citations console.log(report.sources); // every source it used 

Swap the company name and you have a post-mortem generator for any company you're curious about. You can get an API key here.

The Engineers behind the moat

Nvidia gets reduced to one person. These people built the parts developers touch:

• Ian Buck created CUDA and now runs Nvidia's hyperscale and HPC business.
• John Nickolls co-architected CUDA, including its software-managed shared memory, and co-wrote the 2008 paper "Scalable Parallel Programming with CUDA." He died in 2011, far less known than the platform he helped build.
• David Kirk, chief scientist from 1997 to 2009, founded NVIDIA Research.
• Bill Dally left the chair of Stanford's CS department to become chief scientist in 2009. Under him, research produced NVLink and RT cores. He recalls Huang first rejecting NVLink with "we don't do networking." He also had Bryan Catanzaro port Google Brain's cat-recognition network to GPUs, which by Dally's account "ran faster on 48 GPUs than on 16,000 CPUs." That code became cuDNN.
• Chris Malachowsky, co-founder, led hardware engineering and is still at Nvidia as an NVIDIA Fellow.

Jensen and open source: 338 engineers, counted

On the day Huang resigned, TechCrunch wrote that the open-source community "just lost one of its strongest advocates." For a company that sells proprietary chips and a closed-source CUDA, that sounds odd. The record says otherwise.

What Huang did for open source

• 2022: open GPU kernel modules. Nvidia published its Linux GPU kernel modules under a dual GPL/MIT license, starting with the R515 driver (announcement).
• 2025: praising DeepSeek. After DeepSeek-R1 knocked Nvidia's stock down in January 2025, Huang told analysts the bigger story was that DeepSeek had "open sourced a world-class reasoning AI model". In May he called R1 "genuinely a gift to the world's AI industry."
• 2026: defending open weights in Washington. He co-wrote an open letter, signed by 25 companies including Microsoft, Meta, IBM and Palantir, urging the US government not to over-restrict open-weight models (TechCrunch). He also defended Chinese open models directly: "Open-source models that are excellent should be used."
• 2026: buying Hugging Face. On September 3, Nvidia agreed to acquire Hugging Face for $12.93 billion. In his announcement, Huang wrote that Nvidia compute "will not be required to build on or deploy through Hugging Face." The deal had not closed when he resigned.
• Nvidia's own output. Nvidia says it is the largest contributor of open models and data on Hugging Face, with more than 500 models and 250 datasets, plus more than 1,000 open-source projects on GitHub. That includes NeMo, Megatron-LM, TensorRT-LLM, Dynamo, Triton Inference Server, CUTLASS and NCCL. Even Nvidia's NIM containers for LLMs run on vLLM or SGLang underneath.

It's not pure idealism. More teams training and serving their own models means more GPUs sold, and less dependence on a handful of frontier labs that are now designing their own chips. Either way, the open ecosystem got a lot out of it. AI researcher Nathan Lambert put the worry bluntly: losing Huang as CEO would be "very very bad for the open model cause in the US." One Nvidia insider told TechCrunch they don't expect the leadership change to affect Nemotron development.

Counting the engineers

Press releases are one thing. Commits are better evidence. I cloned ten major open-source AI repos and counted distinct @nvidia.com addresses in each commit's author, Co-authored-by and Signed-off-by lines over the 12 months to November 13, 2026.

Treat this as a floor. Plenty of Nvidia engineers commit with personal or GitHub no-reply emails, which this method can't see. You can run it yourself on any repo:

git clone --filter=blob:none --no-checkout https://github.com/v...