# How to Check LlamaFactory Model Support Status: A Complete Guide to the Supported Models Registry

> Quickly check LlamaFactory model support status. Inspect the SUPPORTED_MODELS registry in constants.py for a full list of compatible architectures.

- Repository: [Yaowei Zheng/LlamaFactory](https://github.com/hiyouga/LlamaFactory)
- Tags: how-to-guide
- Published: 2026-03-04

---

**You can verify LlamaFactory's support for any model by inspecting the `SUPPORTED_MODELS` dictionary in [`src/llamafactory/extras/constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/src/llamafactory/extras/constants.py), which serves as the single source of truth for all supported architectures.**

LlamaFactory maintains a comprehensive registry of compatible models for fine-tuning and inference. Understanding how to query this registry allows you to instantly determine whether new model releases are supported before beginning your training workflow.

## Understanding the Model Registry Architecture

The library stores model compatibility data in a centralized registry composed of two core components working together at import time.

### The SUPPORTED_MODELS Dictionary

Located in [`src/llamafactory/extras/constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/src/llamafactory/extras/constants.py), the `SUPPORTED_MODELS` variable is an **OrderedDict** that maps model names to their download locations across Hugging Face, ModelScope, and Modelers Hub. This dictionary represents the definitive source of truth for the entire library.

### The register_model_group Function

The registry populates through a series of `register_model_group` calls within the same file. These helper functions execute during module import to add model families, template configurations, and multimodal flags. For example, the Llama-2 registration block appears around lines 1400-1510 in [`constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/constants.py).

### Human-Readable Documentation

The README.md file contains a "Supported Models" section that generates a markdown table from the same registry data. This provides a quick visual reference without requiring code inspection.

## Programmatically Checking Model Support

Query the registry directly within Python to verify support status dynamically.

### Listing All Supported Models

Import the registry to enumerate every compatible model:

```python
from llamafactory.extras.constants import SUPPORTED_MODELS, MULTIMODAL_SUPPORTED_MODELS

# List all known model names

print("All supported models:")
for name in SUPPORTED_MODELS:
    print(f" • {name}")

# List only multimodal models (vision/audio support)

print("\nMultimodal models:")
for name in sorted(MULTIMODAL_SUPPORTED_MODELS):
    print(f" • {name}")

```

### Verifying a Specific Model

Check if a new model release exists in the registry:

```python
from llamafactory.extras.constants import SUPPORTED_MODELS

model_to_check = "Qwen3-72B-Instruct"

if model_to_check in SUPPORTED_MODELS:
    print(f"✅ {model_to_check} is supported.")
    # Display source URLs for each hub

    for source, url in SUPPORTED_MODELS[model_to_check].items():
        print(f"   {source}: {url}")
else:
    print(f"❌ {model_to_check} is not currently supported.")

```

### Retrieving Chat Templates

Determine the default conversation template for any supported model:

```python
from llamafactory.extras.constants import DEFAULT_TEMPLATE

model = "Gemma-2-9B-Instruct"
template = DEFAULT_TEMPLATE.get(model, "default")
print(f"The chat template for {model} is: {template}")

```

### Dynamic Pre-Flight Checks

Implement validation before export or training operations:

```python
def can_export(model_name: str) -> bool:
    from llamafactory.extras.constants import SUPPORTED_MODELS
    return model_name in SUPPORTED_MODELS

if not can_export("InternVL3-8B-hf"):
    raise RuntimeError("Model not supported for export")

```

## Command Line Verification Methods

Access the registry without writing Python scripts using these terminal commands.

### Direct Python One-Liner

Print the complete sorted model list from any directory:

```bash
python -c "from llamafactory.extras.constants import SUPPORTED_MODELS; \
print('\n'.join(sorted(SUPPORTED_MODELS)))"

```

### CLI Version Check

The `llamafactory-cli` tool displays version information that references the GitHub repository containing the current registry:

```bash
llamafactory-cli version

```

This outputs the welcome banner including version details and repository links, confirming which codebase version you are running.

## Keeping Your Registry Current

Model support expands continuously. Verify you have the latest definitions using these methods.

### Inspect the Source File

Since `SUPPORTED_MODELS` builds at import time, the [`constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/constants.py) file on your current branch reflects exactly which models are available. Check the `main` branch on GitHub for the most recent additions.

### Monitor the README

The "Supported Models" table in [`README.md`](https://github.com/hiyouga/LlamaFactory/blob/main/README.md) updates automatically via CI pipelines to mirror the registry. This offers a faster visual scan than reading source code.

### Review GitHub Releases

Each release tag bundles a snapshot of the registry. Compare the [`constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/constants.py) file across tags to track when specific model families were added historically.

### Contributing New Models

If your target model is missing:

1. **Submit a Pull Request**: Add a `register_model_group` block following the pattern of existing entries in [`src/llamafactory/extras/constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/src/llamafactory/extras/constants.py)
2. **Open an Issue**: The maintainers typically add community-requested models rapidly

## Summary

- **The `SUPPORTED_MODELS` dictionary** in [`src/llamafactory/extras/constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/src/llamafactory/extras/constants.py) serves as the authoritative registry for all compatible models.
- **Programmatic verification** allows dynamic checking via Python imports before training or export operations.
- **Command line access** requires only a single Python one-liner to list all supported architectures.
- **Multimodal capabilities** are tracked separately in `MULTIMODAL_SUPPORTED_MODELS` for vision and audio models.
- **Chat templates** map to models through the `DEFAULT_TEMPLATE` dictionary in the same constants file.
- **Updates flow** from `register_model_group` calls in the source code to the README documentation automatically.

## Frequently Asked Questions

### How do I know if a brand new model is supported by LlamaFactory?

Check the `SUPPORTED_MODELS` dictionary in [`src/llamafactory/extras/constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/src/llamafactory/extras/constants.py). If the model name exists as a key in this OrderedDict, the library supports it. You can verify this programmatically by importing the constant and checking for key membership, or by scanning the "Supported Models" table in the README.md file.

### What is the difference between SUPPORTED_MODELS and MULTIMODAL_SUPPORTED_MODELS?

`SUPPORTED_MODELS` contains all text-based and general-purpose models that LlamaFactory can fine-tune or serve. `MULTIMODAL_SUPPORTED_MODELS` is a separate registry specifically for vision-language and audio-language models that require additional processing capabilities. Check both dictionaries if your model handles images, video, or audio inputs.

### Where does LlamaFactory store the download URLs for supported models?

The download URLs reside within the `SUPPORTED_MODELS` dictionary values. Each model key maps to a dictionary containing source locations for Hugging Face, ModelScope, and Modelers Hub. This structure is defined in [`src/llamafactory/extras/constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/src/llamafactory/extras/constants.py) and populated through the `register_model_group` function calls.

### Can I add support for a new model myself?

Yes. You can extend support by adding a new `register_model_group` block to [`src/llamafactory/extras/constants.py`](https://github.com/hiyouga/LlamaFactory/blob/main/src/llamafactory/extras/constants.py) following the existing pattern used for similar model families. This requires specifying the model name, download URLs, and default chat template. Submit your changes as a Pull Request to the hiyouga/LlamaFactory repository for review.