# How llmfit Detects System RAM and CPU Cores: Complete Implementation Guide

> Learn how llmfit detects system RAM and CPU cores using its SystemSpecs::detect() method. Discover the implementation details and platform-specific fallbacks in this guide.

- Repository: [Alex Jones/llmfit](https://github.com/AlexsJones/llmfit)
- Tags: how-to-guide
- Published: 2026-08-20

---

**`llmfit` detects system RAM and CPU cores through the `SystemSpecs::detect()` method in [`llmfit-core/src/hardware.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/hardware.rs), which uses the `sysinfo` crate to gather hardware data with platform-specific fallbacks for macOS memory reporting and Windows APU memory carve-outs.**

The `llmfit` CLI tool needs accurate hardware information to determine which LLM models can run on a given machine. This article explains how the Rust codebase probes total RAM, available RAM, and CPU core count—plus the edge cases the developers handled for cross-platform reliability.

## Core Detection Logic in SystemSpecs::detect()

The hardware detection pipeline lives in a single function. According to the `llmfit` source code, `SystemSpecs::detect()` at [llmfit-core/src/hardware.rs lines 73-89](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/hardware.rs#L73-L89) performs three main operations:

1. **Initialize and refresh** a `sysinfo::System` instance
2. **Read memory values** from the refreshed system object
3. **Count CPU cores** from the CPU vector

### Memory Detection

Total and available RAM are fetched directly from `sysinfo`:

```rust
use sysinfo::System;

let mut sys = System::new_all();
sys.refresh_all();

let total_bytes = sys.total_memory();
let available_bytes = sys.available_memory();

```

Both values return in bytes. The code converts them to **gibibytes (GiB)** by dividing by `1024³`. This matches how operating systems typically display installed memory.

### CPU Core Detection

Logical CPU cores are determined by vector length:

```rust
let total_cpu_cores = sys.cpus().len();

```

This returns the number of hardware threads, not physical cores. For model-fitting purposes, `llmfit` uses logical cores since that's what matters for concurrent inference workloads.

## Platform-Specific Fallbacks

Raw `sysinfo` data isn't always accurate. The `llmfit` codebase includes two corrections:

### macOS Available Memory Bug

`sysinfo` occasionally reports **zero available memory** on macOS. When this occurs, `SystemSpecs::available_ram_fallback()` (around line 80 in [`hardware.rs`](https://github.com/AlexsJones/llmfit/blob/main/hardware.rs)) queries macOS-specific APIs to estimate free memory.

### Windows APU Memory Carve-Out

AMD APUs with unified memory architecture present a special case. The BIOS reserves a portion of system RAM for the integrated GPU, causing `sys.total_memory()` to underreport physical DIMM capacity.

The `windows_apu_total_ram_gb()` function (lines 96-100) fixes this by:

- Querying `Win32_PhysicalMemory` via WMI
- Comparing against the `sysinfo` total
- Correcting the value when a GPU carve-out is detected

## SystemSpecs Output Structure

The final values populate a struct consumed throughout the application:

```rust
use llmfit_core::hardware::SystemSpecs;

fn main() {
    let specs = SystemSpecs::detect();

    println!("Total RAM:   {:.2} GiB", specs.total_ram_gb);
    println!("Available RAM: {:.2} GiB", specs.available_ram_gb);
    println!("CPU cores:   {}", specs.total_cpu_cores);
    println!("CPU name:    {}", specs.cpu_name);
}

```

Typical output:

```

Total RAM:   31.98 GiB
Available RAM: 28.45 GiB
CPU cores:   16
CPU name:    Intel(R) Core(TM) i9-12900K

```

## Integration with the Model-Fit Pipeline

The CLI entry point in [`llmfit-tui/src/main.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-tui/src/main.rs) calls `SystemSpecs::detect()` during startup. The resulting hardware profile feeds into [`llmfit-core/src/models.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/models.rs), where detected RAM and CPU cores filter and score compatible LLM models.

This design keeps hardware detection centralized in [`hardware.rs`](https://github.com/AlexsJones/llmfit/blob/main/hardware.rs) while making the data available to downstream components without duplication.

## Summary

- **`SystemSpecs::detect()`** in [`llmfit-core/src/hardware.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/hardware.rs) is the single entry point for hardware detection
- **RAM values** come from `sys.total_memory()` and `sys.available_memory()`, converted from bytes to GiB
- **CPU cores** are counted via `sys.cpus().len()` returning logical processors
- **macOS fallback** handles zero-value available memory reports
- **Windows APU correction** adjusts for BIOS-reserved GPU memory using WMI
- Downstream code in [`models.rs`](https://github.com/AlexsJones/llmfit/blob/main/models.rs) uses these specs for model compatibility scoring

## Frequently Asked Questions

### Why does llmfit convert bytes to gibibytes instead of gigabytes?

Operating systems and hardware vendors historically report memory in **binary units (GiB)** while using the "GB" label. By dividing raw byte values by `1024³`, `llmfit` matches user expectations and DIMM labeling—for example, showing "31.98 GiB" for a 32 GB installed module rather than "34.36" (decimal GB).

### What's the difference between sys.total_memory() and sys.available_memory()?

`total_memory()` returns **installed physical RAM**, while `available_memory()` returns **RAM not currently in use** by processes or OS caches. Available memory is what actually matters for loading LLM weights, which is why `llmfit` tracks both values and implements the macOS fallback when the latter reports incorrectly.

### Why does Windows with an AMD APU need special handling?

AMD APUs use **unified memory architecture** where system RAM doubles as GPU memory. The BIOS reserves a fixed portion (typically 512 MB–2 GB) for the integrated GPU, causing `sysinfo` to report less total RAM than physically installed. `llmfit` queries `Win32_PhysicalMemory` to detect this discrepancy and restore the true capacity.

### Can I use SystemSpecs::detect() in my own Rust project?

Yes—the `SystemSpecs` struct and its `detect()` method are **public exports** from `llmfit-core`. Add `llmfit-core` as a dependency and call `SystemSpecs::detect()` directly. The same platform-specific corrections (macOS fallback, Windows APU fix) will apply automatically based on your target OS.