NVIDIA Sells the Whole Ladder. Your Startup Needs One Rung.

The company you are building on was a startup once, too

NVIDIA began as exactly the kind of company reading this guide. In 1993, Jensen Huang, Chris Malachowsky and Curtis Priem spent hours in a booth at a Denny's in East San Jose, talking through a graphics chip company that did not yet have a business plan. Huang, who had washed dishes and bussed tables at Denny's as a teenager in Oregon, later explained the choice of office with impeccable founder logic: "It had all the coffee you could drink and no one could chase you out."

Two years in, the company was close to dead. Its first chip had landed badly, and the graphics architecture it was building for Sega's next console was, Huang concluded, the wrong one. So he did what most founders would rather not do. He told Sega's Shoichiro Irimajiri that NVIDIA could not complete the console, suggested Sega find another partner, and asked to be paid in full anyway, because without that money there would be no NVIDIA. Irimajiri agreed. The five million dollars Sega put into the company bought it roughly six more months, and Huang, retelling the story at National Taiwan University in 2023, reduced it to a single line: "Confronting our mistake, and with humility asking for help, saved NVIDIA."

Sega sold its stake in 2000 for about fifteen million dollars, a trade that only looks sensible if you never check what it would be worth today. The scar tissue stayed with Huang. For years he opened staff presentations by reminding everyone that the company was thirty days from going out of business, and he says he has used the line for more than three decades, trillions of dollars of market value later. It deserves a place above your own desk, because it is the most useful sentence in the semiconductor business.

The second bet built the ecosystem you are about to use. In 2007 NVIDIA released CUDA, a way to program its graphics chips for general-purpose computing, and kept putting the capability on every GPU it made, the cheap gaming cards included, while profits took a beating and shareholders asked what exactly the company was doing. The logic was patient to the point of stubbornness. If every gaming card could run scientific code, then every student, researcher and garage startup was a future CUDA developer. Krizhevsky's bedroom was the first spectacular payoff.

That patience explains NVIDIA's generosity toward founders today. The company gives most of its SDKs away, publishes open models, runs a free startup program and lets you prototype against hosted models without paying. None of that is charity. It is the CUDA strategy applied to you: win the developer early and the data center follows. It is a fair trade for a startup, as long as you make it with your eyes open, which is what the rest of this guide is for.

The stack in five layers, in plain English

Most confusion about NVIDIA comes from treating it as one product. It is a stack, and nearly every name in the catalog sits on one of five layers. Learn the layers and the alphabet soup sorts itself onto shelves, which is roughly the moment the documentation stops feeling hostile.

Two things about this picture matter more than any single product. The first is where the pain lives. Teams rarely fail with NVIDIA because a model was weak. They fail because a driver did not match a toolkit, a JetPack release did not match a module, or a GPU lacked a hardware block that an SDK quietly assumed. Budget real engineering time for layers one and two, even though no customer will ever see them.

The second is continuity. CUDA, TensorRT and most of layer three run, in versions matched to each device, from a Jetson module to a rented H100, so a team can prototype at a desk and deploy to a customer's factory or a cloud region without learning a new programming model. That is the moat NVIDIA spent two decades digging, and as we argued in why NVIDIA is not really a GPU company anymore, it is the part rivals find hardest to copy.

314 families, 25 aisles: what is actually on the shelf

Our catalog sorts the ecosystem into 25 domains, and the shape of the list says something keynotes never do. The single largest aisle is not a glamorous model family. It is CUDA and its core GPU libraries, with 22 entries, followed by NeMo's training and evaluation tools and the biology and medical research models at 21 apiece. Nemotron, the language model line that collects the headlines, fills ten rows.

That proportion is the tell. Models arrive and retire at a dizzying pace: Nemotron alone added three 3.5 language models between August and mid-October. The libraries underneath have been compounding since 2007, and they are where most of NVIDIA's real leverage sits. The practical reading for a founder is blunt: choose models the way you choose dependencies you expect to replace, and choose the platform layer the way you choose a cofounder.

The full list of all 314 families, each with a one-line description and a link to its official page, sits in the appendix at the end of this guide. You will not need most of it this year, which is precisely the point.

The napkin math that decides your hardware

If you remember one number from this guide, make it bytes per parameter. Memory, not raw speed, decides which rung you can stand on, and it is the first wall every AI team hits, from a Toronto bedroom in 2012 to a seed-stage startup this morning. The good news is that the first estimate fits on a napkin.

A model's weights take roughly 2 GB per billion parameters at BF16, 1 GB at 8-bit and 0.5 GB at 4-bit. A 9-billion-parameter model is therefore about 18 GB in BF16 and about 4.5 GB at 4-bit, before anything else is loaded. Then come the extras: the KV cache, which grows with every token of context and every concurrent user, plus activations and the runtime's own working space. The weights are the rent. The KV cache is the utility bill, and it rises every time a new customer moves in.

Three kinds of memory get confused constantly, and the confusion is expensive. System RAM is the computer's general memory. VRAM is the memory on a discrete graphics card, and for AI it is the number that counts: a desktop with 64 GB of RAM and a 12 GB card is a 12 GB machine. Unified memory, on Jetson modules and DGX Spark, is shared between the CPU and the GPU, so the figure on the box is also feeding the operating system and your own application. On the new 64 GB DGX Spark, which goes on sale on 23 October, IT Home reports that about 8 GB is reserved for the system, leaving roughly 56 GB for weights and cache.

The newest trap comes from mixture-of-experts models. Nemotron 3 Nano 30B-A3B activates only about 3.5 billion parameters for each token, which makes it quick. It does not make it small. All 30 billion parameters still have to live in memory, roughly 60 GB at BF16 and 15 GB at 4-bit. Active parameters tell you how fast a model talks. Total parameters tell you how big a room it needs.

Capacity is only half of it, because bandwidth decides how fast a model answers once it fits. DGX Spark holds 128 GB but moves data at about 273 GB/s, while an RTX 5090 holds 32 GB and moves it at roughly 1.8 TB/s, more than six times faster. The Spark is a big room with a narrow door: it loads models no gaming card can hold, then serves them at a stroll. That room has also become pricier. The 128 GB Spark launched at $3,999 in October 2025, rose to $4,699 in February as NVIDIA cited tight memory supply, and now lists at $6,950, while a new 64 GB version from partners starts at $4,999. In 2026 memory is the expensive part of AI hardware, and a startup budget should treat it that way.

The weights are the rent. The KV cache is the utility bill.

If you are weighing a desk-side card instead, our RTX 5090 review covers what 32 GB actually buys, and our complete guide to running LLMs locally goes deeper on quantization formats and runtimes. Two final rules belong on the napkin. Fine-tuning needs far more memory than inference, because gradients and optimizer state join the party, which is why GR00T N1.7 runs inference on a 16 GB card but recommends 40 GB or more to fine-tune. And memory on several GPUs does not merge into one big pool by default. Splitting a model across cards takes software built for it, which is exactly the trick Krizhevsky had to write by hand.

Nine ways to start, from zero GPUs to a rented H100

Here are the nine starter setups from our research, rearranged as a ladder you climb only when the product pushes you. Each one is a real, buildable starting point: the hardware that actually limits it, the NVIDIA pieces that pair with it and a first project small enough to finish in a few weeks. Where a number is an official minimum, we say so. The rest are capacity-planning examples rather than guarantees, and running several models at once will need more.

Rung 0: no GPU at all

The most underrated rung costs nothing in hardware. A laptop with 8 to 16 GB of RAM can call hosted models through NVIDIA Build and NIM endpoints, and NeMo Agent Toolkit can wire those calls into an assistant that searches your own documents and cites its sources. Members of NVIDIA's free Developer Program get hosted endpoints for prototyping and downloadable NIM microservices for development and testing on up to 16 GPUs. If you cannot excite a customer with a hosted model, a GPU will not save you, and you will have learned that for the price of a coffee.

We made the same argument from the other direction in our skeptical look at RTX Spark: unless your data is regulated or has to stay offline, renting frontier intelligence by the token is very hard to beat with a box under the desk. Our local LLM versus cloud breakdown walks through the cases where the balance tips the other way.

Rung 1: sensors that feed a brain somewhere else

The next three setups share one architecture: cheap hardware senses or acts at the edge, a PC or an API does the thinking, and the network in between quietly becomes part of your product. The ESP32-S3 streams sensor readings for a Nemotron model to summarize, the Arduino UNO R4 WiFi executes a short list of commands that a model on a nearby PC is allowed to send it, and the Raspberry Pi 5 ships camera frames to a GPU server running DeepStream and TensorRT. In each case the hard engineering is not the AI. It is deciding exactly what the small board is permitted to do when the big brain is slow, wrong or offline.

Be clear about what these boards are. They are nerve endings, not brains. None of them runs CUDA, Isaac Sim or a large model on board, and the Raspberry Pi's built-in GPU is not a CUDA GPU at all. Their value at this rung is the data they start collecting on day one, which for many industrial and retail startups becomes the real moat long after the model at the other end has been swapped twice.

Rung 2: NVIDIA at the edge

The first rung with an NVIDIA chip on the device is a Jetson Orin Nano: 8 GB of unified memory, a 128 GB NVMe drive in our example build, and a developer kit that launched at $249 and has cost $399 since NVIDIA raised Jetson prices in July 2026. Pair it with the JetPack, TensorRT and DeepStream releases that support the module, and a single USB camera can count parts on a production line, process every frame on the device, log the events that matter and send summaries upstream. Nothing leaves the building that does not need to.

This is the rung where unit economics stop being theoretical. Every customer site needs a box, every box has a bill of materials, and the model has to fit in memory it shares with the operating system. Teams that prototype on a big desktop card often discover here that their model needs to go on a diet, which is what quantization and TensorRT exist for. Better to find that out in month two than in the pilot.

Rung 3: the RTX desk

Three setups live on a desktop RTX card, and they serve very different companies. A robotics team can run Isaac Sim, Isaac Lab and Replicator to test a warehouse robot's route in a virtual building, changing racks and lighting and generating camera data for every failure. NVIDIA's official x86 minimum for Isaac Sim is a GeForce RTX 4080 with 16 GB of VRAM, 32 GB of RAM and 50 GB of SSD, its recommended tier is an RTX 5080 with 64 GB of RAM, and Isaac Lab training wants more on top. Simulation is the cheapest robot you will ever crash.

A manipulation startup can step up to a card with 24 GB or more, such as an RTX 4090 or RTX 5090, plus an RGB-D camera and a robot arm. FoundationPose estimates where a part sits and how it is turned, cuRobo plans collision-free motion, and GR00T N1.7, which needs a GPU with 16 GB or more for inference, supplies learned skills. The sane order is to prove the grasp in simulation first, then run slow, supervised trials on the real arm.

The third RTX setup serves media companies rather than robots. NVIDIA Broadcast, which needs at least an RTX 2060-class GPU and 8 GB of RAM, strips microphone noise, swaps backgrounds and keeps a speaker framed during a live class, and the AI for Media SDKs let developers build the same effects into their own products. If your startup ships to creators, your customers' graphics cards are your deployment platform, and the features they can run follow the GPU generation rather than the price tag.

Simulation is the cheapest robot you will ever crash.

Rung 4: rented muscle

The last rung is the one founders reach for too early. A cloud H100 with 80 GB of VRAM, paired with 128 GB of RAM and 500 GB of SSD in our example node, is the right tool for tuning a small language model with LoRA on your company's own example answers, measuring it with NeMo Evaluator, shrinking it with Model Optimizer and testing it against the original in a pilot. On-demand H100s rent for roughly $2 to $12 per GPU-hour depending on the provider, and the direction this year has been up as capacity tightened.

Rent by the hour until the utilization math says otherwise. A LoRA run on a small model is measured in hours, not months, and a GPU you bought would sit idle the rest of the time. Specialist GPU clouds usually undercut the hyperscalers on list price, and our Nebius analysis explains why renting out GPUs is a commodity business the clouds themselves are trying to escape. For a startup, the bigger saving is still the simplest one: turn the meter off between experiments.

Which rung is yours? A five-question test

Most founders never need to read all 314 entries. They need to answer five questions in order and stop at the first yes. Each answer points to a rung and to the handful of NVIDIA pieces worth learning first, which is a far shorter reading list than the catalog suggests.

Notice what the test never asks: which GPU is fastest. Speed matters later, once you know what you are selling. What decides the first rung is where your product has to run and what it has to touch, and founders usually know those answers long before a benchmark does.

Seven traps that quietly burn a seed round

None of these traps appears in a keynote, and each one has cost real teams real money. They are listed roughly in the order founders tend to walk into them, with the habit that avoids each one.

The free on-ramps, and what they are really for

NVIDIA runs several programs that cost a startup nothing, plus one paid shortcut to rented GPUs, and the free ones are worth joining as soon as you qualify. Just read each one for what it is: a well-built funnel into the CUDA stack, generous because the company expects to be repaid in loyalty and, eventually, in GPUs.

Join Inception as soon as you are incorporated and have a working website. It is free, and its two most useful benefits for an early team, preferred hardware pricing and cloud credits, cut exactly the costs this guide keeps warning about. Then design for an exit you hope never to use: keep your application talking to standard interfaces, such as the OpenAI-style APIs that NIM language model endpoints expose, containerize everything, and treat proprietary SDKs as accelerators rather than foundations, unless the SDK is your product.

When NVIDIA is not the answer, and why it usually still is

Honesty requires the other side of the ledger. Apple's new Mac Studio with the M5 Ultra offers up to 512 GB of unified memory and more than four times the memory bandwidth of DGX Spark, which makes it an excellent quiet box for running very large open models, although without CUDA none of NVIDIA's GPU-accelerated SDKs run on it. AMD's Ryzen AI Max systems pack 128 GB of unified memory at prices well below the Spark's, and AMD's Instinct accelerators compete hard on memory capacity in the cloud, with a ROCm software stack that has matured but stays thinner outside the mainstream frameworks. Google's TPUs and AWS Trainium can be compelling at scale and tie you to one cloud. And for many software startups, a frontier model behind an API beats every box on this list.

The reason NVIDIA still wins most first decisions is breadth, not benchmarks. No other vendor covers a palm-sized edge module, a desktop simulator, a data center GPU and the software that joins them with one programming model and one hiring pool. That breadth is also the lock-in, so take it knowingly: use NVIDIA where it is unmatched, at the edge, in simulation and in GPU-heavy training, and keep the rest of your stack boring and portable.

A 90-day plan for the first rung

A plan is only useful if it tells you what not to do. This one keeps you on the cheapest rung for as long as possible and turns every climb into a decision rather than a reflex.

If your product lives or dies on inference cost, keep the metric we unpacked in tokens per watt next to your cost per request. Ninety days is enough to learn whether you have a product. It is rarely enough to justify owning serious silicon, and if the plan ends with you still renting, that is not a failure. It is the plan working.

When the numbers do justify owning hardware, the decision turns into an infrastructure project, and our AI factory blueprint is the place to start, with Vera Rubin NVL72 as the view from the very top of the ladder. Few startups will ever need that view, and the ones that do will get there by climbing, not by jumping.

The verdict: pay for the rung, not the ladder

NVIDIA has built the deepest toolbox in computing, and the only truly wrong way to use it is all at once. Start on the cheapest rung that can embarrass you in front of a real customer. Rent before you buy, because a GPU you own on day one is a bet on a product you have not finished. Do the memory math before every purchase, read the recipe rather than the label, and put a license line next to every model you touch.

And remember the bedroom. The breakthrough that turned a graphics company into the engine of the AI era did not come from the biggest machine of 2012. It came from a sharp question, modest hardware and the stubbornness to work around a memory wall. Krizhevsky did not need a data center. He needed the right two cards and a better question. So do you.

Questions founders ask

Do I need an NVIDIA GPU to start an AI startup?

No. A laptop with 8 to 16 GB of RAM can call hosted models through NVIDIA Build and NIM endpoints, and NVIDIA's free Developer Program covers prototyping. Buy or rent GPUs only when latency, privacy, cost per request or an offline requirement forces you to.

What is the cheapest NVIDIA hardware for running AI on a device?

The Jetson Orin Nano Super developer kit, with 8 GB of unified memory, is the usual entry point for on-device AI with JetPack, TensorRT and DeepStream. It launched at $249 and has cost $399 since NVIDIA raised Jetson prices in July 2026. Microcontrollers such as the ESP32-S3 or the Arduino UNO R4 WiFi cost less, but they act as sensors and actuators and do not run CUDA or large models.

How much GPU memory does a language model need?

For the weights alone, roughly 2 GB per billion parameters at BF16 and 0.5 GB at 4-bit, so a 9-billion-parameter model needs about 18 GB or 4.5 GB. Add memory for the KV cache, activations and runtime. Mixture-of-experts models need memory for all of their parameters, not only the active ones.

Can Isaac Sim run on an H100 or A100?

No. NVIDIA's Isaac Sim requirements state that GPUs without RT cores, including the A100 and H100, are not supported. The official x86 minimum is a GeForce RTX 4080 with 16 GB of VRAM, 32 GB of RAM and 50 GB of SSD space, and the recommended tier is an RTX 5080 with 64 GB of RAM.

Is NVIDIA Inception free, and does it take equity?

NVIDIA Inception is free and takes no equity, and funding stage and revenue do not matter. Applicants must be incorporated, less than ten years old, run a working website and have a clear use for NVIDIA technology; consulting firms, resellers, cloud providers and listed companies are excluded. Members get self-paced courses, preferred pricing on select hardware and software, cloud credits from NVIDIA and partners, and possible introductions to investors.

Can I use NVIDIA's open models in a commercial product?

Often, but check each model card. The Nemotron Open Model License states that works are commercially usable, the Nemotron 3.5 releases use OpenMDW-1.1, and GR00T N1.7 pairs Apache 2.0 code with weights under the NVIDIA Open Model License, while research code such as Instant-NGP uses a non-commercial license. Partner models listed on NVIDIA Build carry their own terms.

Is NIM free to use in production?

No. NIM is free for research, development and testing through the NVIDIA Developer Program on up to 16 GPUs. Self-hosted production use requires an NVIDIA AI Enterprise license, which NVIDIA says begins at $4,500 per GPU per year, with a free 90-day trial.

Should a startup buy a DGX Spark or rent cloud GPUs?

Rent first in most cases. DGX Spark holds up to 128 GB of unified memory but moves data at about 273 GB/s, and the 128 GB model now lists at $6,950. It suits teams that must keep large models local for privacy or offline work; for bursty training and experiments, hourly cloud GPUs are usually the cheaper path.

Glossary for your first week

Twenty terms you will meet again and again in NVIDIA's documentation, defined the way you will actually need them. Keep this section handy, because the documentation rarely stops to explain itself.

CUDA

NVIDIA's platform for programming its GPUs for general-purpose computing, released in 2007. Almost everything else in the stack is built on it.

VRAM

The memory on a discrete graphics card. For AI work it is the number that decides which models fit.

Unified memory

Memory shared by the CPU and GPU, as on Jetson modules and DGX Spark. The operating system and your application share it with the model.

BF16, FP8, FP4 and 4-bit

Number formats for model weights. Fewer bits per parameter means less memory and usually more speed, at some risk to accuracy.

Quantization

Converting a model's weights to fewer bits so it fits, and runs faster, on smaller hardware.

KV cache

Memory a language model uses to keep track of the conversation so far. It grows with context length and with every concurrent user.

Mixture of experts (MoE)

A model that activates only some of its parameters for each token. Fast, but every parameter still has to fit in memory.

LoRA

A fine-tuning method that trains small add-on weights instead of the whole model, which cuts memory and cost.

Inference and fine-tuning

Inference runs a trained model. Fine-tuning updates it and needs far more memory.

NIM

NVIDIA's packaged model microservices with standard APIs: free for development and testing, licensed for production.

TensorRT

NVIDIA's compiler and runtime that optimizes trained models for fast inference on its GPUs.

JetPack

The operating system, drivers and AI software stack for Jetson modules.

Blueprint

A reference application that wires NVIDIA components into a working example, such as RAG or video search.

RT cores

Ray tracing hardware on RTX GPUs. Isaac Sim requires them, and the A100 and H100 do not have them.

Compute capability

NVIDIA's version number for a GPU architecture: 7.5 for Turing (RTX 20 series), 8.9 for Ada (RTX 40 series), 9.0 for Hopper (H100). SDKs use it to decide which GPUs they support.

GGUF

A file format for quantized model weights, used by llama.cpp and the local tools built on it.

SXM

NVIDIA's socketed module form of its data center GPUs, mounted on the board instead of in a PCIe slot. SXM parts run at higher power with faster links, and the H100 SXM is markedly quicker than the H100 PCIe card.

TOPS and TFLOPS

Trillions of operations, or floating-point operations, per second. Vendors quote peaks at their most flattering precision, so compare only like for like.

RGB-D camera

A camera that records color and depth for every pixel, which lets a robot locate objects in three dimensions.

vGPU

NVIDIA's software for sharing one physical GPU among several virtual machines. It is licensed separately and runs on data center and professional cards, not GeForce.

Appendix: the full map, and the old names

All 314 families, by aisle

Every family in our catalog, grouped into its 25 aisles, with a one-line description and a link to the official page or model card. Status tags flag research code, previews, limited access and partner models, which deserve an extra look at license and support terms before a customer depends on them.

Old names you will still meet in tutorials

Older tutorials and sample projects still use these names. Here is how each maps to the current product or status, so a stale blog post does not send you down a dead end.

Sources and method

This guide is built on a catalog compiled on 21 October 2026 from official NVIDIA product documentation, model cards and project repositories, with the claims in the article rechecked against current sources on 22 October 2026. Research, early-access and partner models are flagged as such, and a listing on NVIDIA Build or NGC does not by itself mean NVIDIA developed a model. Requirements change with every release, so check the linked page before you buy hardware. Gigabyte figures are approximate decimal capacities, and prices are list prices at the time of writing.

• Isaac Sim requirements, NVIDIA (minimum and recommended hardware, RT core note).
• Isaac GR00T N1.7 repository, NVIDIA (hardware requirements and licenses).
• Run NIM anywhere and the NIM FAQ, NVIDIA (Developer Program access, production licensing and pricing).
• NVIDIA Inception, NVIDIA (eligibility, benefits and FAQ).
• NVIDIA Nemotron Open Model License and the Nemotron 3.5 Bolt model card.
• Instant-NGP and StyleGAN3 repositories, NVIDIA Research (license terms).
• CHM releases AlexNet source code, Computer History Museum (how and where AlexNet was trained).
• Jensen Huang's 2023 NTU commencement speech, transcript (the Sega story and the CUDA bet).
• Huang returns to Denny's, NVIDIA blog (the founding booth).
• Huang's Denny's years, Fortune (the founding booth and the business-plan book he never finished).
• Jetson Orin Nano Super Developer Kit, JetsonHacks (the $249 launch price and 102 GB/s of memory bandwidth).
• DGX Spark pricing changes, Implicator (the 64 GB model and the 128 GB price history).
• 64 GB DGX Spark launch, Guru3D (the 23 October sale date and, citing IT Home, the memory reserved for the system).
• NVIDIA raises Jetson prices, CNX Software (the Orin Nano Super kit moving from $249 to $399).
• Mac Studio with M5 Max and M5 Ultra, Apple (unified memory and bandwidth).
• Parabricks installation requirements, NVIDIA (GPU memory, system RAM and CPU threads).
• H100 rental prices in 2026, Akash Network (on-demand price ranges).