Cómo detectamos tu GPU y puntuamos la IA local

Cómo funciona

Todo se ejecuta en tu navegador. Cuando visitas el sitio, usamos APIs del navegador para detectar tu GPU, CPU y memoria — y después calculamos qué modelos de IA pueden correr en tu hardware y a qué velocidad. No se envía ningún dato a un servidor. Todo se calcula en el cliente.

Detección de hardware

Usamos tres APIs del navegador para identificar tu hardware. No hace falta instalar nada ni extensiones.

// Get GPU renderer string
const canvas = document.createElement("canvas");
const gl = canvas.getContext("webgl2");
const ext = gl.getExtension("WEBGL_debug_renderer_info");
const gpu = gl.getParameter(ext.UNMASKED_RENDERER_WEBGL);
// → "ANGLE (NVIDIA, NVIDIA GeForce RTX 4090, ...)"
// → "Apple M4 Pro GPU"

const adapter = await navigator.gpu.requestAdapter();
const info = adapter.info;
// info.device → "nvidia geforce rtx 4090"
// info.architecture → "ampere"

const cores = navigator.hardwareConcurrency; // → 16
const ram = navigator.deviceMemory;         // → 8 (GB, approximate)

Base de datos de GPUs

Una vez identificamos tu GPU, la buscamos en una base de datos integrada de ~40 GPUs (NVIDIA, AMD, Intel) y ~12 chips Apple Silicon. Cada entrada contiene la capacidad de VRAM y el ancho de banda de memoria — los dos números que más importan para correr modelos de IA localmente.

// Example entries from the GPU database
const GPU_DB = {
  "RTX 4090":    { vram: 24,  bw: 1008 }, // GB/s
  "RTX 4060":    { vram: 8,   bw: 272  },
  "RX 7900 XTX": { vram: 24,  bw: 960  },
};

const APPLE_DB = {
  "m4 max":   { ram: 36,  bw: 546 },
  "m4 pro":   { ram: 24,  bw: 273 },
  "m4":       { ram: 16,  bw: 120 },
};

Requisitos de VRAM

Cada modelo en nuestra base de datos tiene requisitos de VRAM precalculados para cada nivel de cuantización. La fórmula es directa:

Añadimos una constante de 0.5 GB para overhead de runtime (motor de inferencia, contexto CUDA/Metal) más un 10% de margen de seguridad para caché KV y buffers de runtime. Por ejemplo, un modelo de 70B en Q4_K_M (4-bit) necesita aproximadamente 70 × 4 ÷ 8 = 35 GB × 1.1 + 0.5 ≈ 39 GB.

// How we calculate VRAM for each quantization
// Adds ~0.5 GB overhead for KV cache + inference runtime
const RUNTIME_OVERHEAD = 0.5; // GB

function makeQuants(paramsBillions) {
  const base = paramsBillions;
  return [
    { name: "Q2_K",   vram: round(base * 0.35 + RUNTIME_OVERHEAD) },
    { name: "Q4_K_M", vram: round(base * 0.55 + RUNTIME_OVERHEAD) },
    { name: "Q6_K",   vram: round(base * 0.75 + RUNTIME_OVERHEAD) },
    { name: "Q8_0",   vram: round(base * 0.95 + RUNTIME_OVERHEAD) },
    { name: "F16",    vram: round(base * 1.85 + RUNTIME_OVERHEAD) },
  ];
}

Algoritmo de puntuación

La puntuación (0–100) combina tres factores para responder: "¿Qué tan bien correrá este modelo en tu hardware?"

const efficiency = isAppleSilicon ? 0.65 : 0.70;
const toksPerSec = (bandwidthGBs / modelVRAM) * efficiency;

// Speed → Score mapping
80+ tok/s → 100 pts     // Instant
40+ tok/s →  85 pts     // Fast
20+ tok/s →  65 pts     // Good
10+ tok/s →  45 pts     // Usable
 5+ tok/s →  25 pts     // Slow
 <5  tok/s →  10 pts     // Painful

const memPct = (modelVRAM / totalMemory) * 100;

// Memory usage → Score mapping
 ≤30% → 100 pts     // Plenty of room
 ≤50% →  80 pts     // Comfortable
 ≤70% →  55 pts     // Moderate
 ≤85% →  30 pts     // Tight
 >85% →  10 pts     // Very tight

const qualityBonus = Math.min(15, Math.log2(paramsBillions + 1) * 2.5);
// 7B → ~7.5 pts, 70B → ~15 pts (capped)

Escala de calificación

La puntuación final se traduce en una etiqueta de estado:

Clasificación de ajuste

Antes de puntuar, clasificamos cada modelo en uno de tres estados según la memoria:

Estimación de tokens/s

Estimamos la velocidad de inferencia usando un modelo simple limitado por ancho de banda. La inferencia de LLMs está casi completamente limitada por la velocidad a la que puedes leer los pesos desde memoria — el cómputo raramente es el cuello de botella.

La eficiencia es 0.70 para GPUs dedicadas y 0.65 para Apple Silicon (la memoria unificada tiene algo más de overhead). Esto da una estimación conservadora — el rendimiento real puede variar ±20% según el tamaño de batch, la longitud de contexto y el formato de cuantización.

Fuentes de datos

La información de los modelos se recopila de múltiples fuentes y se cura manualmente:

Estadísticas de HuggingFace

Obtenemos los conteos de descargas y likes de HuggingFace en build time usando su API pública:

// Fetch model stats from HuggingFace API
const res = await fetch(
  `https://huggingface.co/api/models/${repoId}`
);
const data = await res.json();
// data.downloads → 2_450_000
// data.likes     → 12_500

Apple Silicon: memoria unificada

Los Mac con Apple Silicon comparten memoria entre CPU y GPU (arquitectura de memoria unificada). Esto significa que el modelo puede usar hasta ~75% de la RAM total — mucho más que las GPUs dedicadas, que están limitadas a su VRAM. Un MacBook Pro con 36 GB puede correr modelos que necesitan ~27 GB, mientras que un PC con una GPU de 8 GB no puede. Tenemos esto en cuenta en nuestros cálculos tratando Apple Silicon como un único pool con un tope usable del 75%.

Privacidad y transparencia

Toda la detección de hardware y puntuación ocurre en tu navegador. No se envía ningún dato a un servidor. El nombre de la GPU, la RAM y los resultados de benchmark nunca salen de tu dispositivo. El sitio está construido con Astro y no envía JavaScript a las páginas que no lo necesitan.