TL;DR: Alibaba DAMO Academy published RADAR, an abdominal-CT diagnostic model, in Science on September 18, 2026, and released the code and checkpoints. It scored an AUC of 0.913 across 146 findings on 39,160 real examinations and outperformed most of the radiologists it was tested against. It runs on a single consumer GPU — roughly 16GB of VRAM at peak — but two things in the headlines are wrong: it is not Apache 2.0, and nobody has published a parameter count, “7B” included.

What you’ll actually be able to do with it:

• Run a Science-published, radiologist-grade research model on a 16–24GB GPU, entirely offline, against the public MERLIN demo data or your own contrast-enhanced abdominal CT volumes
• Get a CSV of positive/negative scores across 146 abdominal findings per scan — this is a screening-style classifier with organ-level grounding, not a chatbot you talk to
• Learn a completely different local-AI stack than the Ollama one: NIfTI volumes, TotalSegmentator organ masks, and a pinned-dependency PyTorch pipeline

Honest take: If you already own a used RTX 3090, this is the most interesting weekend project of the fall — a genuine frontier medical research model that happens to fit your card. But read the license before you build anything on it (CC BY-NC-SA 4.0, non-commercial), and read the repo’s own disclaimer before you read anything into its output: research use only, not a diagnostic device.

The story that went around Hacker News and the tech press this week — “Alibaba open-sources AI that detects cancer and ~150 conditions” — is one of those rare cases where the headline undersells the science and oversells the licensing at the same time. The science is real and published in Science. The “open-source” part needs an asterisk big enough to see from orbit. And the practical question this site exists to answer — can your GPU run it? — turns out to have a satisfying answer: yes, probably, but not through any tool you’re currently using.

Here’s what RADAR actually is, what the pipeline actually looks like, and what hardware it actually needs.

What RADAR is (the verified version)

RADAR — “An Expert-Level Generalist AI for Abdominal CT Diagnosis” — is a vision-language model from Alibaba’s DAMO Academy, trained on more than 400,000 contrast-enhanced abdominal CT examinations paired with 15 million anatomy-aware image–text pairs mined from clinical reports. No manual annotation: the model learned organ-level alignment directly from what radiologists wrote about each scan. The paper appeared in Science on September 18, 2026 (DOI: 10.1126/science.aec6129).

The headline numbers, from the paper itself:

Metric	Result
Internal validation	AUC 0.913 (95% CI 0.911–0.915) across 146 findings, 39,160 examinations
External validation	AUC 0.874–0.912 across 8 outside centers
Pathology-confirmed cancers (liver, pancreas, stomach, colorectal)	AUC 0.891–0.984
Reader study	Assistance raised 26 radiologists’ diagnostic sensitivity ~10%, cut reading time >30%
Coverage	18 abdominal anatomical structures, 146 imaging findings

In the reader study, the standalone model outperformed 23 of the 26 radiologists on average. That’s the line that made the news, and per the paper it’s not hype.

What RADAR is not: a general medical chatbot, an X-ray reader, an MRI reader, or a photo-of-a-mole classifier. It handles one modality — contrast-enhanced abdominal CT — and produces per-finding probability scores, not prose diagnoses. The demo inference script outputs a CSV of positive scores per finding (the bundled MERLIN evaluation covers 22 conditions like abdominal aortic aneurysm and pleural effusion; the full model scores 146).

The two claims in the headlines that don’t survive contact with the repo

“Apache 2.0.” Several outlets reported the release as Apache 2.0. The actual LICENSE file in the repository is Creative Commons Attribution-NonCommercial-ShareAlike 4.0 — that’s the license GitHub displays for the repo, and it covers what’s in it. CC BY-NC-SA means: research and personal use are fine, share-alike applies to derivatives, and commercial deployment is off the table without a separate agreement from Alibaba. If you were imagining a paid second-opinion service or a telehealth integration, this license ends that plan before your GPU spins up. For a home lab running it on your own scans, you’re squarely within the permitted use.

The repo also carries its own plain-language warning, worth quoting in full: “The Radar model is currently intended for research purposes only. Further improvements and prospective clinical studies are still required before it can be used directly for clinical deployment.” This is not a medical device. Nothing it tells you about a scan is a diagnosis.

“7B parameters.” A parameter count circulated with the aggregator coverage, but it doesn’t appear in the paper, the repository, or the Hugging Face org where the checkpoints live (alongside RADAR+ variants and English/Chinese BERT tokenizers). What is documented, from people who ran it locally: the checkpoint is roughly 5GB on disk. For context, a 7B LLM at FP16 is ~14GB. Whatever RADAR’s exact count is, this is a small model by 2026 standards — the training data, not the parameter budget, is where the expertise lives.

The stack: forget Ollama, this is a research pipeline

If your mental model of “running a model locally” is ollama pull and a chat window, recalibrate. RADAR is built on LAVIS (Salesforce’s vision-language framework), nnU-Net, MONAI, and 3D-ResNets-PyTorch. There is no GGUF, no llama.cpp support, no LM Studio entry. You get a conda environment and Python scripts:

conda create -n radar python=3.10
conda activate radar
pip install -r requirements.txt
cd RADAR_inference
python inference_demo.py

The requirements.txt tells you how research code ages: transformers==4.25 (a late-2022 release), timm==0.4.12, torch>=1.10.0, plus MONAI, SimpleITK, and nibabel for the medical-imaging side. That hard pin on an old transformers version is why the dedicated conda environment isn’t optional — install this into the environment where your other 2026-era tooling lives and pip will either downgrade half your stack or refuse. Isolate it and it installs clean.

Input format is NIfTI (.nii.gz) medical image volumes, not JPEGs and not raw DICOM folders — if your scans came from a hospital CD as DICOM, you’ll be converting them first, and the repo’s preprocessing docs assume you arrive with volumes ready.

The pipeline has a stage zero: organ segmentation

Here’s the part every summary skipped, and it changes the hardware math. RADAR doesn’t look at a raw CT volume. Its organ-level alignment needs to know where the organs are, so the documented preprocessing pipeline is:

1. Run TotalSegmentator V1 on the original CT volume to produce 104-structure segmentation masks — a separate open-source model, installed and run on its own
2. Merge those 104 structures into 36 major anatomical structures with the provided process_img_mask.py
3. Resample image and mask to [1, 1, 5] mm spacing
4. Only then run inference_demo.py, which writes the per-finding score CSV

So “running RADAR” is really running two models back to back. TotalSegmentator has its own well-documented GPU appetite: 5.2–11.4GB of GPU memory depending on scan extent and resolution — a small abdominal study needs about 6.1GB at 1.5mm resolution, 5.2GB at the fast 3mm setting (TotalSegmentator docs). It also has a CPU mode (--fast, --roi_subset) if you’d rather spend minutes than VRAM.

A real trap and the fix

The docs say TotalSegmentator V1, and that single character matters. The current pip default is V2, which segments a different, larger structure set (117+ classes versus V1’s 104) with different class indices. RADAR’s merge script expects V1’s 104-structure output to fold into its 36 target structures — feed it V2 masks and the organ mapping silently no longer means what the script thinks it means. The fix is to install the V1 release explicitly (it’s preserved on the TotalSegmentator repo and PyPI history) rather than grabbing the latest, exactly as the RADAR preprocessing guide specifies. When a research repo pins a version, it’s load-bearing.

VRAM: what it actually uses

The inference docs say: “Inference can be run on a single GPU or multiple GPUs (A100 or H20). A single GPU is sufficient for this demo.” DAMO tested on data-center cards because that’s what DAMO has. The measured reality from MindStudio’s local run: the model initializes using under 1GB of VRAM, then climbs to roughly 16GB once fully loaded and processing a scan — with tunable knobs in the inference script that can shrink that further. Their conclusion matches ours: single consumer or prosumer GPU territory, no server rack required.

Mapping that onto the cards this site tracks, with September 2026 street prices:

GPU tier	Runs RADAR?	Notes
8–12GB (RTX 3060, 4070)	No, not comfortably	~16GB peak inference doesn’t fit; TotalSegmentator alone wants up to 11.4GB on larger studies
16GB (RTX 5060 Ti 16GB, $679–$805 street, $429 MSRP)	Borderline	At the documented ~16GB peak you have zero headroom; expect to lean on the memory-reduction options and run TotalSegmentator in CPU mode
24GB (used RTX 3090, $1,150–$1,350 used)	Yes, comfortably	Both pipeline stages fit on-card with room to spare; this is the card the math points at, again
No GPU	Rent	A 24GB RTX 3090 on Vast.ai runs from ~$0.07/hr — a full evening of experimentation costs less than a coffee

The recurring lesson of this site holds one more time: the used RTX 3090 keeps being the right answer for workloads nobody predicted when it launched. If you’re weighing that card for LLM work anyway, RADAR is a bonus use case, not a reason — see the 24GB VRAM guide for what else that tier unlocks.

One honest unknown: per-scan inference time on consumer cards isn’t published anywhere we could verify. DAMO’s own materials describe inference in seconds per volume on data-center hardware; nobody has posted RTX 3090 timings yet. Given the ~5GB checkpoint, expect the TotalSegmentator stage — not RADAR itself — to dominate your wall-clock time.

What a home lab can actually do with it

Realistically, three things:

Learn the medical-imaging stack. This is the most legitimately useful outcome. NIfTI volumes, organ segmentation, resampling spacing, MONAI — this is the toolchain of an entire research field, and RADAR is the most consequential model ever to land in it with runnable code. If your local-AI experience is text models, this is a genuinely different discipline sharing your GPU. It’s a sharper systems lesson than another multimodal image model install, because the preprocessing is the work.

Reproduce the demo science. The repo ships inference and evaluation scripts against the public MERLIN test set, so you can verify the reported numbers on 22 findings yourself — actual reproducible published science, on your own hardware, for the cost of electricity.

Look at your own scans — with both eyes open. If you have contrast-enhanced abdominal CT data from your own medical history, RADAR will score it, privately, on your machine — the privacy argument for local AI at maximum strength, since medical imaging is the last data anyone should upload to a free web demo. But the repo’s disclaimer isn’t boilerplate: this model is research-only, its output is a probability score, and a score is not a radiologist. Anything that worries you goes to a doctor; nothing that reassures you should keep you from one. Where it was validated to help, per the paper, is assisting radiologists — the 10% sensitivity gain came from experts using it, not replacing them.

What a home lab can’t do: build a product on it. The CC BY-NC-SA license makes that a conversation with Alibaba, not a git clone.

Worth a card upgrade?

No — and that’s the honest verdict this time. RADAR is a reason to use a 24GB card, not a reason to buy one. It’s a single-modality research model you’ll run a handful of times, under a non-commercial license, with no ecosystem behind it yet. If you’re at 12GB today, rent the evening on Vast.ai before you spend $1,200 on a use case you might exhaust in a weekend. If you’re buying a 24GB card anyway for LLM work — and the buying guide will tell you when that’s justified — RADAR comes free with the decision.

The bigger signal is directional. A Science-published model that beats most radiologists in its lane now fits in 16GB of consumer VRAM with a ~5GB checkpoint. Domain-expert models are getting small faster than general models are getting cheap. Whatever medical, legal, or scientific model makes headlines next year, the odds it runs on the card already in your machine keep improving — which is the entire thesis of owning that card.

What to actually buy

Your situation	Do this	Price	Why
You already own a used RTX 3090	Try it this weekend	$0	A frontier medical research model that fits your card
You want to run it and don’t own 24GB	Used RTX 3090 24GB	$1,150–$1,350	The tier this model was sized for
You’re evaluating it for clinical work	Don’t — this is a research model	—	Research weights are not a medical device
You want faster iteration on scans	Used RTX 4090	$2,150–$2,350	Same 24GB, meaningfully faster throughput

FAQ

Is DAMO RADAR really open source? The code and checkpoints are public and free to download, but the license is CC BY-NC-SA 4.0 — non-commercial, share-alike. That fails the standard open-source definition (which requires allowing commercial use). Call it “open weights, research license.” Sister site aifoss.dev tracks which “open” AI releases are actually open — this one lands in the asterisk column.

Can it read X-rays, MRIs, or photos? No. It was trained exclusively on contrast-enhanced abdominal CT and covers 18 abdominal structures and 146 findings. Chest X-rays, brain MRIs, dermatology photos — all out of scope.

Does it run in Ollama or LM Studio? No, and it likely never will — it’s a 3D vision-language pipeline (LAVIS/MONAI lineage), not a GGUF-compatible LLM. It runs from Python scripts in a conda environment, after a TotalSegmentator V1 preprocessing pass.

How much VRAM do I need? About 16GB at peak during inference per the one documented local run, with under 1GB at initialization and tunable memory options. The TotalSegmentator preprocessing stage needs 5.2–11.4GB on GPU or can run on CPU. A 24GB card runs the whole pipeline without thought; a 16GB card is possible with care.

Is it a 7B model? Unknown — no parameter count appears in the paper, the repo, or the model pages, despite the “7B” figure circulating in coverage. The checkpoint is ~5GB on disk, which suggests something well under 7B at half precision.

Can I use it to diagnose myself? No. The repository states it’s for research purposes only, and it has not been through prospective clinical validation for standalone use. Run it for curiosity and education; take medical questions to medical professionals.

Recommended Gear

Products linked in this guide:

• Used RTX 3090 24GB — $1,150–$1,350 used (Sep 2026); runs both pipeline stages on-card with headroom
• RTX 5060 Ti 16GB — $679–$805 street (Sep 2026, $429 MSRP); the borderline-viable floor for this workload

Sources

• An expert-level generalist AI for abdominal CT diagnosis — Science (DOI: 10.1126/science.aec6129)
• alibaba-damo-academy/damo-radar — GitHub (code, docs, THIRD_PARTY_LICENSES)
• RADAR repository LICENSE (CC BY-NC-SA 4.0) — GitHub
• RADAR preprocessing guide (TotalSegmentator V1, 104→36 structures, [1,1,5] resampling) — GitHub
• RADAR inference guide (single GPU sufficient; A100/H20 reference) — GitHub
• RADAR checkpoints — Hugging Face (radar-generalist)
• How to Run Alibaba’s RADAR Medical AI Model Locally — MindStudio (~16GB peak VRAM, ~5GB checkpoint)
• Alibaba open-sources medical AI model that can detect cancer and nearly 150 conditions — South China Morning Post
• Alibaba DAMO Academy Open-Sources Expert-Level Abdominal CT Model DAMO RADAR in Science — Pandaily
• TotalSegmentator — GitHub (V1 104 structures; GPU memory 5.2–11.4GB by study size)
• TotalSegmentator: robust segmentation of 104 anatomical structures in CT images — arXiv
• Hacker News discussion — item 49761840

Last updated September 23, 2026. Prices and specs change; verify current rates before purchasing. RADAR is a research model under a non-commercial license — nothing in this article or in the model’s output is medical advice.

Get the numbers before you buy

New GPU and mini-PC benchmarks, VRAM thresholds, and price checks — sent when there's something worth acting on, not on a schedule. No spam, unsubscribe anytime.

Email address Subscribe