# TimesFM Memory Requirements: Hardware Specs for TimesFM 1.0 and 2.0

> Discover the memory requirements for TimesFM 1.0 and 2.0. Learn the RAM and VRAM specs needed for optimal performance with TimesFM models. Understand hardware needs for inference.

- Repository: [Google Research/timesfm](https://github.com/google-research/timesfm)
- Tags: performance
- Published: 2026-04-02

---

**TimesFM 1.0 requires a minimum of 4 GB RAM (2 GB VRAM) while TimesFM 2.0 requires 8 GB RAM (4 GB VRAM), with the 200 million parameter model consuming roughly 1.5–3 GB CPU RAM during inference and the 500 million parameter model requiring 3.5–6 GB.**

Provisioning sufficient memory is critical when deploying the `google-research/timesfm` forecasting models. Understanding the exact **TimesFM memory requirements** prevents out-of-memory failures during batch inference and ensures optimal performance across CPU and GPU environments. The repository provides explicit hardware profiles for both model versions that quantify RAM, VRAM, and runtime overhead needs.

## TimesFM 1.0 vs 2.0 Memory Specifications

The two major checkpoints differ significantly in parameter count and memory footprint.

### Model Size and Minimum Requirements

According to the `MODEL_PROFILES` dictionary defined in [`timesfm-forecasting/scripts/check_system.py`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/scripts/check_system.py) (lines 46–64), the hardware thresholds are:

- **TimesFM 1.0 (200M parameters)**: Minimum 4 GB RAM, recommended 8 GB RAM; minimum 2 GB VRAM, recommended 4 GB VRAM.
- **TimesFM 2.0 (500M parameters)**: Minimum 8 GB RAM, recommended 16 GB RAM; minimum 4 GB VRAM, recommended 8 GB VRAM.

The minimum values represent absolute low-water marks, while recommended values provide comfortable headroom for typical batch sizes without triggering out-of-memory (OOM) errors.

### CPU RAM Consumption During Inference

For CPU-only deployments, the [`timesfm-forecasting/references/system_requirements.md`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/references/system_requirements.md) file (lines 98–110) provides specific consumption estimates:

- **TimesFM 1.0**: Approximately 1.5 GB for small batches, scaling to 3 GB for large batches.
- **TimesFM 2.0**: Approximately 3.5 GB for small batches, scaling to 6 GB for large batches.

These figures include the model weights—approximately 800 MB for the 200M checkpoint and 2 GB for the 500M checkpoint—plus roughly 0.5 GB overhead and an input-buffer term that scales with context length and series count.

## How to Check Your System Memory Against TimesFM Requirements

The repository includes a built-in pre-flight checker to validate your hardware against these specifications before running forecasts.

### Command Line Verification

Run the `check_system` module to print a memory verdict for your selected model version:

```bash

# Check TimesFM 1.0 requirements

python -m timesfm_forecasting.scripts.check_system --model v1.0

# Check TimesFM 2.0 requirements  

python -m timesfm_forecasting.scripts.check_system --model v2.0

```

The CLI outputs explicit pass/fail indicators with actual versus required memory:

```

[RAM] 4.2 GB (≥ 4.0 GB) ✅ PASS
[VRAM] 2.1 GB (≥ 2.0 GB) ✅ PASS

```

### Programmatic Memory Queries

For integration into wrappers or UI components, import `MODEL_PROFILES` directly from [`check_system.py`](https://github.com/google-research/timesfm/blob/main/check_system.py) to access the requirement thresholds:

```python
from timesfm_forecasting.scripts.check_system import MODEL_PROFILES

def get_requirements(version: str):
    profile = MODEL_PROFILES[version]
    return {
        "min_ram_gb": profile["min_ram_gb"],
        "recommended_ram_gb": profile["recommended_ram_gb"],
        "min_vram_gb": profile["min_vram_gb"],
        "recommended_vram_gb": profile["recommended_vram_gb"],
    }

print(get_requirements("v2.0"))

# {'min_ram_gb': 8.0, 'recommended_ram_gb': 16.0,

#  'min_vram_gb': 4.0, 'recommended_vram_gb': 8.0}

```

## Estimating Memory for Custom Datasets

Beyond static requirements, actual memory consumption scales with your specific forecasting workload. The `estimate_memory_gb` function in [`timesfm-forecasting/scripts/check_system.py`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/scripts/check_system.py) calculates total RAM needs based on dataset characteristics.

```python
from timesfm_forecasting.scripts.check_system import estimate_memory_gb

mem = estimate_memory_gb(
    num_series=2000,          # Number of time series to forecast together

    context_length=1024,      # Maximum context length utilized

    horizon=256,
    batch_size=32,
    model_version="v2.0",
)

print(f"Estimated total RAM (with 20% buffer): {mem['total_with_buffer']:.2f} GB")

```

This helper accounts for the input-buffer term that grows with the number of series and context length, adding a 20% safety buffer to prevent OOM conditions during peak allocation.

## Summary

- **TimesFM 1.0 (200M)**: Requires 4 GB minimum RAM (2 GB VRAM), uses ~1.5–3 GB CPU RAM during inference.
- **TimesFM 2.0 (500M)**: Requires 8 GB minimum RAM (4 GB VRAM), uses ~3.5–6 GB CPU RAM during inference.
- **Validation**: Use `timesfm_forecasting.scripts.check_system` CLI or `MODEL_PROFILES` dictionary to verify hardware compatibility.
- **Dynamic estimation**: The `estimate_memory_gb` function calculates workload-specific memory needs including buffer overhead.

## Frequently Asked Questions

### What is the minimum GPU memory needed to run TimesFM 2.0?

TimesFM 2.0 requires a minimum of 4 GB VRAM according to the `MODEL_PROFILES` definition in [`timesfm-forecasting/scripts/check_system.py`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/scripts/check_system.py). However, 8 GB is recommended to handle typical batch sizes without triggering out-of-memory errors during inference.

### Why does CPU RAM usage exceed the model checkpoint size?

The 200M checkpoint occupies approximately 800 MB and the 500M checkpoint approximately 2 GB on disk. However, runtime CPU RAM usage includes roughly 0.5 GB overhead plus input buffers that scale with context length and batch size, resulting in 1.5–3 GB for v1.0 and 3.5–6 GB for v2.0 during active forecasting.

### How can I verify my system meets TimesFM requirements before running forecasts?

Run the built-in pre-flight checker via `python -m timesfm_forecasting.scripts.check_system --model v1.0` (or `v2.0`). This script compares your available RAM and VRAM against the `MODEL_PROFILES` thresholds and reports pass/fail status with specific gigabyte measurements.

### Does increasing the context length affect memory requirements?

Yes, memory consumption scales with context length due to input buffering and KV-cache management. Use the `estimate_memory_gb` function from [`check_system.py`](https://github.com/google-research/timesfm/blob/main/check_system.py) to calculate precise requirements when increasing `context_length` or `num_series`, as these parameters directly impact the input-buffer term and total RAM allocation.