What Does a "Perfect" Fit Level Mean in llmfit? Understanding GPU Memory Requirements

A "Perfect" fit level in llmfit means the model's recommended memory fits entirely within available GPU VRAM with headroom for efficient execution—this is the highest-ranking fit level and requires GPU acceleration.

In llmfit, the FitLevel enum determines how comfortably a large language model's memory requirements align with your system's available resources. The "Perfect" variant represents optimal hardware-model compatibility, triggering the fastest GPU-based execution path. According to the llmfit source code, this fit level is defined in llmfit-core/src/fit.rs and serves as the top tier in a four-level ranking system used throughout the codebase.

Defining the Perfect Fit Level

The FitLevel enum in llmfit-core/src/fit.rs establishes four descending ranks:

Perfect > Good > Marginal > TooTight

The Perfect variant requires three conditions:

• GPU availability — CPU-only paths explicitly cannot achieve this level; the source comment states "CPU paths cap at Good"
• Sufficient VRAM — the model's recommended memory fits entirely within GPU memory
• Execution headroom — enough remaining VRAM for efficient inference without memory pressure

When these conditions are met, llmfit selects RunMode::Gpu as the optimal execution strategy.

Hardware Requirements for Perfect Fit

GPU Dependency

Achieving a Perfect fit is hardware-constrained to GPU acceleration. The source comment in llmfit-core/src/fit.rs at lines 775-782 makes this limitation explicit:

// From llmfit-core/src/fit.rs
/// Perfect: Model fits comfortably in GPU memory with headroom
/// CPU paths cap at Good
Perfect,

This architectural decision ensures that Perfect models always execute on the fastest available hardware path.

Memory Calculation

The fit assessment compares model-specified memory requirements against detected GPU VRAM. The ModelFit struct (defined in the same file) stores both the calculated fit level and the underlying memory metrics used to determine it.

Working with Perfect Fits in Code

Checking Fit Level Programmatically

Use pattern matching or direct equality checks against FitLevel::Perfect:

use llmfit_core::fit::{FitLevel, ModelFit};

fn select_gpu_if_perfect(fit: &ModelFit) -> ExecutionPlan {
    if fit.fit_level == FitLevel::Perfect {
        ExecutionPlan::GpuAccelerated
    } else {
        ExecutionPlan::CpuFallback
    }
}

Filtering Models by Perfect Fit

The TUI implementation in llmfit-tui/src/tui_app.rs demonstrates how to filter model lists:

// In llmfit-tui/src/tui_app.rs, lines 1819-1823
match fit_filter {
    FitFilter::Perfect => fit.fit_level == FitLevel::Perfect,
    FitFilter::Good => fit.fit_level == FitLevel::Good,
    FitFilter::Marginal => fit.fit_level == FitLevel::Marginal,
    FitFilter::All => true,
}

CLI Flag for Perfect Fits

The command-line interface exposes a --perfect flag mapped in llmfit-tui/src/main.rs (lines 1149-1150):

# Display only models with Perfect fit level

cargo run -- --cli fit --perfect

This flag filters the model registry before presentation, equivalent to the programmatic check above.

Visual Indicators in the TUI

The display layer in llmfit-tui/src/display.rs renders Perfect fits with green color coding (lines 252-255), providing immediate visual feedback during model selection. This consistent color mapping helps users quickly identify optimal hardware matches.

When Perfect Fit Cannot Be Achieved

Systems without discrete GPUs, or with insufficient VRAM for the target model, will receive Good as the maximum achievable level. The llmfit ranking system intentionally reserves Perfect for configurations where GPU acceleration provides measurable performance benefits without memory constraints.

Summary

• Definition: Perfect fit means full model memory requirements satisfied in GPU VRAM with execution headroom
• Requirement: GPU hardware mandatory; CPU execution capped at Good
• Implementation: Defined in llmfit-core/src/fit.rs with filtering in TUI and CLI components
• Consequence: Triggers RunMode::Gpu for optimal inference performance
• Ranking: Highest of four levels (Perfect > Good > Marginal > TooTight)

Frequently Asked Questions

Can a CPU-only system achieve a Perfect fit level?

No. The llmfit source code explicitly limits CPU-only paths to Good as the maximum fit level. The FitLevel::Perfect variant requires GPU acceleration with sufficient VRAM. This constraint is documented in the enum definition at llmfit-core/src/fit.rs with the comment "CPU paths cap at Good."

How does llmfit calculate whether a model achieves Perfect fit?

The calculation compares the model's declared memory requirements (VRAM for GPU execution) against detected GPU memory capacity. A buffer for execution overhead is applied. The exact threshold values and headroom calculations are implemented in the FitLevel determination logic within llmfit-core/src/fit.rs.

What happens when multiple GPUs are available?

The source analysis does not indicate multi-GPU logic for Perfect fit determination. The current implementation appears to assess fit against individual GPU memory rather than aggregated multi-GPU configurations. Check llmfit-core/src/fit.rs for the actual detection implementation in your version.

Is Perfect fit required for model execution?

No. llmfit supports execution at all fit levels. Perfect indicates optimal hardware-model pairing for performance. Models at Good, Marginal, or even TooTight levels may still run with degraded performance, CPU fallback, or memory-swap strategies depending on configuration.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}