Jensen Huang’s Exit and the Open-Source Stack: A Practical Roundup
The headline is a leadership story, but the operational question for anyone running inference is narrower and more uncomfortable: which parts of your AI stack depend on Nvidia being generous?
Jensen Huang’s resignation puts a genuine question mark over Nvidia’s open-source posture — the Hugging Face acquisition, the Nemotron family of open-weight models, and the company’s lobbying against model-distribution restrictions. None of those commitments are contractual. They are strategic choices made by a founder-led company, and founder-led companies are exactly the ones whose side bets get re-examined during a transition. A new CEO inherits a fiduciary duty to the moat, not to the community.
So treat this as a good moment for a stack audit. Below is a roundup of the tools that matter, when each one earns its place, when it doesn’t, and where the pricing traps are hiding.

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: techcrunch.com
What actually changed (and what didn’t)
Nothing has been revoked. CUDA still ships, PyTorch still runs, and the open-weight releases are still on Hugging Face today. What changed is confidence in the trend line. Three specific exposures are worth naming:
- Stewardship risk. Hugging Face is the neutral ground of open-weight AI. If Nvidia’s ownership turns it into a preferential lane for NIM and TensorRT, the “neutral” part erodes even if nothing is explicitly paywalled.
- Licensing risk. Nemotron weights are open, but open-weight licenses are revocable in the next release, not retroactively. The risk is that the next model is API-only.
- Advocacy risk. Nvidia has been one of the louder corporate voices against rules that would restrict model distribution. A new CEO with different political calculus changes that, and regulation follows the loudest voices.
That’s the frame. Now the tools.
1. CUDA, cuDNN, TensorRT — still the default, still the trap
Use when: you need maximum performance per dollar on H100/H200/Blackwell, you’re doing anything latency-sensitive, or your team already has kernel-level expertise.
Don’t use when: you need portability across accelerators, or you’re a small team that can’t afford a rewrite if hardware supply or pricing shifts.
CUDA isn’t going anywhere — it’s the revenue engine. But note the distinction: CUDA’s existence is safe; CUDA’s terms are not. Watch for changes in redistribution terms for containerized CUDA, which is how most people actually consume it now.
2. NIM and NeMo — the licensed layer to scrutinize
Use when: you want a supported, packaged inference microservice with an SLA and you’re already all-in on Nvidia GPUs. NIM’s value is real: prebuilt containers, autoscaling, and enterprise support you don’t have to staff.
Don’t use when: you’re cost-sensitive at scale, or you want to run the same model on AMD or Trainium without re-architecting.
This is the layer where the open-source question bites hardest. NIM is proprietary, per-GPU-hour licensed, and designed to be the commercial floor under the open-weight ecosystem. If Hugging Face becomes a funnel into NIM, “open weights” starts to mean “open weights, closed serving.” NeMo, meanwhile, is genuinely open-source but increasingly tuned for Nvidia-only paths.
3. TensorRT-LLM — fast, opinionated, portable-ish
Use when: you’re serving on Nvidia and you want the last 20–30% of throughput. For dense models with static shapes, it’s hard to beat.
Don’t use when: you iterate on model architecture weekly. Compilation overhead and engine rebuilds punish fast-moving research. Also: it’s a one-way door in practice — nobody ports off TensorRT-LLM cheaply.
4. Hugging Face — the asset everyone is watching
Use when: always, for model discovery, tokenizers, datasets, and the transformers/datasets/accelerate trio. It’s the closest thing the field has to a shared library.
Don’t use when: you need guaranteed upstream neutrality for a competitive product, or you’re depending on Hub-hosted inference as a production dependency.
The acquisition is the single most consequential item here. Practically, watch three things: whether Hub search ranking changes, whether transformers gains Nvidia-specific fast paths that are slower elsewhere, and whether Enterprise Hub pricing is bundled with NIM. Any of those is a soft lock-in that no license text will announce.
5. PyTorch + Triton — the neutral middle
Use when: you want a stack that runs on Nvidia, AMD, and increasingly on TPUs without a rewrite. PyTorch is foundation-governed; Triton is the compiler layer that makes non-CUDA backends viable.
Don’t use when: you need bleeding-edge Nvidia features on day one — you’ll wait months for upstream support.
This is your best hedge. Budget for it now.
6. vLLM, SGLang, llama.cpp — the escape hatch
Use when: you want throughput without a vendor relationship. vLLM’s PagedAttention is production-proven, SGLang wins on structured output and prefix caching, llama.cpp handles CPU/edge and GGUF quantization.
Don’t use when: you need a support contract, or your workload is so latency-critical that hand-tuned TensorRT is worth the salary.
These are your portability insurance. They’re not as fast as TensorRT-LLM on Nvidia — typically 10–30% behind on dense models — but they run on ROCm and TPU today.
7. ROCm, oneAPI, Trainium/TPU — the alternatives, honestly assessed
Use when: you have a second-source mandate, price pressure, or a workload that’s memory-bandwidth-bound rather than compute-bound.
Don’t use when: you need the long tail of CUDA libraries. ROCm’s gap is not raw matmul performance anymore; it’s the ecosystem — obscure ops, third-party kernels, debugging tools.

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: techcrunch.com
Quick decision table
| Tool | Use when | Skip when | Lock-in |
|---|---|---|---|
| CUDA/TensorRT | Peak perf on Nvidia | Portability matters | High |
| NIM | Want SLA + packaging | Cost-sensitive at scale | High |
| TensorRT-LLM | Stable arch, max throughput | Fast iteration | High |
| Hugging Face | Always (discovery, libs) | Production inference dependency | Medium |
| PyTorch/Triton | Multi-vendor future | Need day-one Nvidia features | Low |
| vLLM / SGLang | Portable serving | Need vendor support | Low |
| ROCm / Trainium | Second source, cost | Long-tail CUDA libs | Low |
Pricing caveats
Four traps worth flagging explicitly, because they’re where “open” costs money:
- Per-GPU-hour licensing compounds. NIM-style licensing scales with your fleet, not your usage. Idle replicas still bill. Model your 3 a.m. floor, not your peak.
- Enterprise Hub seats are sticky. Per-seat pricing on collaboration tooling is the classic expansion vector. Budget for growth, and negotiate multi-year caps before you standardize.
- “Free” tiers are qualification funnels. Free inference credits and community tiers exist to identify accounts large enough to convert. Don’t build a product on a tier with no contractual uptime.
- Porting is the real price. The license is the cheap part. Re-quantizing, re-tuning, and re-validating a model on ROCm or Trainium is typically 4–12 engineer-weeks per model family. That number belongs in your vendor comparison, and almost nobody puts it there.
A 90-day hedge plan
- Inventory your exposure. Count models served through NIM, TensorRT-LLM, and anything gated behind a Hugging Face feature.
- Benchmark one model on vLLM + ROCm. Pick your highest-volume model. If it lands within 25% of your current throughput, you have a real second source.
- Pin your weights. Mirror every open-weight model you depend on to your own object storage. Licenses are irrevocable for published weights; availability isn’t.
- Read the next Nemotron license. This is the tell. If it moves from open weights to API-only, the strategy has changed.
- Don’t rip out CUDA. That’s overreaction. Hedging is cheap; migrating is not.
The honest summary: Nvidia’s open-source support is likely to survive the transition, because it serves the moat. But “likely” is doing a lot of work in that sentence, and the cost of a hedge is a few engineer-weeks. The cost of being wrong is your serving bill.
Sources
- TechCrunch, “Jensen Huang’s exit puts Nvidia’s support for open source in question,” November 12, 2026 — https://techcrunch.com/2026/11/12/jensen-huangs-exit-puts-nvidias-support-for-open-source-in-question/
- Vendor documentation for CUDA, TensorRT-LLM, NIM, NeMo, ROCm, and Hugging Face Hub (consult current licensing pages before committing to procurement).
- Project documentation for PyTorch, Triton, vLLM, SGLang, and llama.cpp.



