Cómo Construir una Webapp Moderna con IA e i18n en 2026

Mira, tenemos que hablar sobre i18n en 2026.

La mayoría de los tutoriales te dirán que traduzcas las cadenas de texto manualmente, contrates traductores o uses alguna API de Google Translate medio chapucera. Pero aquí está la cuestión: estás viviendo en la era de Claude Sonnet 4.5. ¿Por qué sigues traduciendo como si fuera 2019?

Voy a mostrarte cómo construimos una webapp en producción que habla 17 idiomas con fluidez, utilizando una arquitectura i18n de dos piezas que realmente tiene sentido:

1. Lingui para la extracción, compilación y la magia en tiempo de ejecución (runtime).
2. Un paquete i18n personalizado impulsado por LLMs para traducciones automatizadas y conscientes del contexto.

¿Nuestro stack? Create T3 Turbo con Next.js, tRPC, Drizzle, Postgres, Tailwind y el AI SDK. Si no estás usando esto en 2026, necesitamos tener una conversación diferente.

A construir.

---

El Problema con la i18n Tradicional

Los flujos de trabajo tradicionales de i18n se ven así:

# Extraer cadenas
$ lingui extract

# ??? De alguna manera conseguir traducciones ???
# (contratar traductores, usar servicios dudosos, llorar)

# Compilar
$ lingui compile

¿Ese paso intermedio? Es una pesadilla. O bien estás:

• Pagando $$$ por traductores humanos (lento, costoso)
• Usando APIs de traducción básicas (ciegas al contexto, suenan robóticas)
• Traduciendo manualmente (no escala)

Nosotros lo hacemos mejor.

---

La Arquitectura de Dos Piezas

Aquí está nuestra configuración:

┌─────────────────────────────────────────────┐
│  Next.js App (Integración con Lingui)      │
│  ├─ Extrae cadenas con macros               │
│  ├─ Componentes Trans/t en tu código        │
│  └─ i18n en runtime con catálogos compilados│
└─────────────────────────────────────────────┘
              ↓ genera archivos .po
┌─────────────────────────────────────────────┐
│  Paquete @acme/i18n (Traducción con LLM)  │
│  ├─ Lee archivos .po                        │
│  ├─ Traduce por lotes con Claude/GPT-5      │
│  ├─ Consciente del contexto y del producto  │
│  └─ Escribe archivos .po traducidos         │
└─────────────────────────────────────────────┘
              ↓ compila a TypeScript
┌─────────────────────────────────────────────┐
│  Catálogos de Mensajes Compilados           │
│  └─ Traducciones rápidas y tipadas (runtime)│
└─────────────────────────────────────────────┘

La Pieza 1 (Lingui) maneja la experiencia del desarrollador. La Pieza 2 (Paquete i18n Personalizado) maneja la magia de la traducción.

Profundicemos en cada una.

---

Parte 1: Configurando Lingui en Next.js

Instalación

En tu monorepo T3 Turbo:

# En apps/nextjs
pnpm add @lingui/core @lingui/react @lingui/macro
pnpm add -D @lingui/cli @lingui/swc-plugin

Configuración de Lingui

Crea apps/nextjs/lingui.config.ts:

import type { LinguiConfig } from "@lingui/conf";

const config: LinguiConfig = {
  locales: [
    "en", "zh_CN", "zh_TW", "ja", "ko",
    "de", "fr", "es", "pt", "ar", "it",
    "ru", "tr", "th", "id", "vi", "hi"
  ],
  sourceLocale: "en",
  fallbackLocales: {
    default: "en"
  },
  catalogs: [
    {
      path: "<rootDir>/src/locales/{locale}/messages",
      include: ["src"],
    },
  ],
};

export default config;

17 idiomas listos para usar. Porque, ¿por qué no?

Integración con Next.js

Actualiza next.config.js para usar el plugin SWC de Lingui:

const linguiConfig = require("./lingui.config");

module.exports = {
  experimental: {
    swcPlugins: [
      [
        "@lingui/swc-plugin",
        {
          // Esto hace que tus builds sean más rápidas
        },
      ],
    ],
  },
  // ... resto de tu configuración
};

Configuración del Lado del Servidor

Crea src/utils/i18n/appRouterI18n.ts:

import { setupI18n } from "@lingui/core";
import { allMessages } from "./initLingui";

const locales = ["en", "zh_CN", "zh_TW", /* ... */] as const;

const instances = new Map<string, ReturnType<typeof setupI18n>>();

// Pre-crear instancias i18n para todos los locales
locales.forEach((locale) => {
  const i18n = setupI18n({
    locale,
    messages: { [locale]: allMessages[locale] },
  });
  instances.set(locale, i18n);
});

export function getI18nInstance(locale: string) {
  return instances.get(locale) ?? instances.get("en")!;
}

¿Por qué? Los Server Components no tienen React Context. Esto te da traducciones del lado del servidor.

Provider del Lado del Cliente

Crea src/providers/LinguiClientProvider.tsx:

"use client";

import { I18nProvider } from "@lingui/react";
import { setupI18n } from "@lingui/core";
import { useEffect, useState } from "react";

export function LinguiClientProvider({
  children,
  locale,
  messages
}: {
  children: React.ReactNode;
  locale: string;
  messages: any;
}) {
  const [i18n] = useState(() =>
    setupI18n({
      locale,
      messages: { [locale]: messages },
    })
  );

  useEffect(() => {
    i18n.load(locale, messages);
    i18n.activate(locale);
  }, [locale, messages, i18n]);

  return <I18nProvider i18n={i18n}>{children}</I18nProvider>;
}

Envuelve tu app en layout.tsx:

import { LinguiClientProvider } from "@/providers/LinguiClientProvider";
import { getLocale } from "@/utils/i18n/localeDetection";
import { allMessages } from "@/utils/i18n/initLingui";

export default function RootLayout({ children }: { children: React.ReactNode }) {
  const locale = getLocale();

  return (
    <html lang={locale}>
      <body>
        <LinguiClientProvider locale={locale} messages={allMessages[locale]}>
          {children}
        </LinguiClientProvider>
      </body>
    </html>
  );
}

Usando Traducciones en Tu Código

En Server Components:

import { msg } from "@lingui/core/macro";
import { getI18nInstance } from "@/utils/i18n/appRouterI18n";

export async function generateMetadata({ params }) {
  const locale = getLocale();
  const i18n = getI18nInstance(locale);

  return {
    title: i18n._(msg`Pricing Plans | acme`),
    description: i18n._(msg`Choose the perfect plan for you`),
  };
}

En Client Components:

"use client";

import { Trans, useLingui } from "@lingui/react/macro";

export function PricingCard() {
  const { t } = useLingui();

  return (
    <div>
      <h1><Trans>Pricing Plans</Trans></h1>
      <p>{t`Ultimate entertainment experience`}</p>

      {/* Con variables */}
      <p>{t`${credits} credits remaining`}</p>
    </div>
  );
}

La sintaxis de macro es CLAVE. Lingui extrae esto en tiempo de compilación (build time).

---

Parte 2: El Paquete de Traducción Impulsado por IA

Aquí es donde la cosa se pone buena.

Estructura del Paquete

Crea packages/i18n/:

packages/i18n/
├── package.json
├── src/
│   ├── translateWithLLM.ts      # Traducción core con LLM
│   ├── enhanceTranslations.ts   # Procesador por lotes
│   └── utils.ts                  # Ayudantes

package.json

{
  "name": "@acme/i18n",
  "version": "0.1.0",
  "dependencies": {
    "@acme/ai": "workspace:*",
    "openai": "^4.77.3",
    "pofile": "^1.1.4",
    "zod": "^3.23.8"
  }
}

El Motor de Traducción LLM

Aquí está la salsa secreta - translateWithLLM.ts:

import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";
import { z } from "zod";

const translationSchema = z.object({
  translations: z.array(
    z.object({
      msgid: z.string(),
      msgstr: z.string(),
    })
  ),
});

export async function translateWithLLM(
  messages: Array<{ msgid: string; msgstr: string }>,
  targetLocale: string,
  options?: { model?: string }
) {
  const prompt = `You are a professional translator for acme, an AI-powered creative platform.

Translate the following strings from English to ${getLanguageName(targetLocale)}.

CONTEXT:
- acme is a platform for AI chat, image generation, and creative content
- Keep brand names unchanged (acme, Claude, etc.)
- Preserve HTML tags, variables like {count}, and placeholders
- Adapt culturally where appropriate
- Maintain tone: friendly, creative, engaging

STRINGS TO TRANSLATE:
${JSON.stringify(messages, null, 2)}

Return a JSON object with this structure:
{
  "translations": [
    { "msgid": "original", "msgstr": "translation" },
    ...
  ]
}`;

  const result = await generateText({
    model: openai(options?.model ?? "gpt-4o"),
    prompt,
    temperature: 0.3, // Más bajo = más consistente
  });

  const parsed = translationSchema.parse(JSON.parse(result.text));
  return parsed.translations;
}

function getLanguageName(locale: string): string {
  const names: Record<string, string> = {
    zh_CN: "Simplified Chinese",
    zh_TW: "Traditional Chinese",
    ja: "Japanese",
    ko: "Korean",
    de: "German",
    fr: "French",
    es: "Spanish",
    pt: "Portuguese",
    ar: "Arabic",
    // ... etc
  };
  return names[locale] ?? locale;
}

Por qué funciona esto:

• Consciente del contexto: El LLM sabe qué es "acme".
• Salida estructurada: El esquema Zod asegura un JSON válido.
• Baja temperatura: Traducciones consistentes.
• Preserva el formato: HTML y variables se mantienen intactos.

Procesador de Traducción por Lotes

Crea enhanceTranslations.ts:

import fs from "fs";
import path from "path";
import pofile from "pofile";
import { translateWithLLM } from "./translateWithLLM";

const BATCH_SIZE = 30; // Traducir 30 cadenas a la vez
const DELAY_MS = 1000; // Límite de velocidad (Rate limiting)

export async function enhanceTranslations(
  locale: string,
  catalogPath: string
) {
  const poPath = path.join(catalogPath, locale, "messages.po");
  const po = pofile.parse(fs.readFileSync(poPath, "utf-8"));

  // Encontrar ítems sin traducir
  const untranslated = po.items.filter(
    (item) => item.msgid && (!item.msgstr || item.msgstr[0] === "")
  );

  if (untranslated.length === 0) {
    console.log(`✓ ${locale}: All strings translated`);
    return;
  }

  console.log(`Translating ${untranslated.length} strings for ${locale}...`);

  // Procesar en lotes
  for (let i = 0; i < untranslated.length; i += BATCH_SIZE) {
    const batch = untranslated.slice(i, i + BATCH_SIZE);
    const messages = batch.map((item) => ({
      msgid: item.msgid,
      msgstr: item.msgstr?.[0] ?? "",
    }));

    try {
      const translations = await translateWithLLM(messages, locale);

      // Actualizar archivo PO
      translations.forEach((translation, index) => {
        const item = batch[index];
        if (item) {
          item.msgstr = [translation.msgstr];
        }
      });

      console.log(`  ${i + batch.length}/${untranslated.length} translated`);

      // Guardar progreso
      fs.writeFileSync(poPath, po.toString());

      // Rate limiting
      if (i + BATCH_SIZE < untranslated.length) {
        await new Promise((resolve) => setTimeout(resolve, DELAY_MS));
      }
    } catch (error) {
      console.error(`  Error translating batch: ${error}`);
      // Continuar con el siguiente lote
    }
  }

  console.log(`✓ ${locale}: Translation complete!`);
}

El procesamiento por lotes evita los límites de tokens y ahorra costos.

El Script de Traducción

Crea apps/nextjs/script/i18n.ts:

import { enhanceTranslations } from "@acme/i18n";
import { exec } from "child_process";
import { promisify } from "util";

const execAsync = promisify(exec);

const LOCALES = [
  "zh_CN", "zh_TW", "ja", "ko", "de",
  "fr", "es", "pt", "ar", "it", "ru"
];

async function main() {
  // Paso 1: Extraer cadenas del código
  console.log("📝 Extracting strings...");
  await execAsync("pnpm run lingui:extract --clean");

  // Paso 2: Auto-traducir cadenas faltantes
  console.log("\n🤖 Translating with AI...");
  const catalogPath = "./src/locales";

  for (const locale of LOCALES) {
    await enhanceTranslations(locale, catalogPath);
  }

  // Paso 3: Compilar a TypeScript
  console.log("\n⚡ Compiling catalogs...");
  await execAsync("npx lingui compile --typescript");

  console.log("\n✅ Done! All translations updated.");
}

main().catch(console.error);

Añade a package.json:

{
  "scripts": {
    "i18n": "tsx script/i18n.ts",
    "lingui:extract": "lingui extract",
    "lingui:compile": "lingui compile --typescript"
  }
}

Ejecutando Tu Pipeline de i18n

# Un comando para gobernarlos a todos
$ pnpm run i18n

📝 Extracting strings...
Catalog statistics for src/locales/{locale}/messages:
┌──────────┬─────────────┬─────────┐
│ Language │ Total count │ Missing │
├──────────┼─────────────┼─────────┤
│ en       │         847 │       0 │
│ zh_CN    │         847 │     123 │
│ ja       │         847 │      89 │
└──────────┴─────────────┴─────────┘

🤖 Translating with AI...
Translating 123 strings for zh_CN...
  30/123 translated
  60/123 translated
  90/123 translated
  123/123 translated
✓ zh_CN: Translation complete!

⚡ Compiling catalogs...
✅ Done! All translations updated.

Eso es todo. Añade una nueva cadena en tu código, ejecuta pnpm i18n, y ¡boom! - traducido a 17 idiomas.

---

Cambio de Idioma (Locale Switching)

No olvides la parte de UX. Aquí tienes un selector de idioma:

"use client";

import { useLocaleSwitcher } from "@/hooks/useLocaleSwitcher";
import { useLocale } from "@/hooks/useLocale";

const LOCALES = {
  en: "English",
  zh_CN: "简体中文",
  zh_TW: "繁體中文",
  ja: "日本語",
  ko: "한국어",
  // ... etc
};

export function LocaleSelector() {
  const currentLocale = useLocale();
  const { switchLocale } = useLocaleSwitcher();

  return (
    <select
      value={currentLocale}
      onChange={(e) => switchLocale(e.target.value)}
    >
      {Object.entries(LOCALES).map(([code, name]) => (
        <option key={code} value={code}>
          {name}
        </option>
      ))}
    </select>
  );
}

La implementación del hook:

// hooks/useLocaleSwitcher.tsx
"use client";

import { setUserLocale } from "@/utils/i18n/localeDetection";

export function useLocaleSwitcher() {
  const switchLocale = (locale: string) => {
    setUserLocale(locale);
    window.location.reload(); // Forzar recarga para aplicar el idioma
  };

  return { switchLocale };
}

Guarda la preferencia en una cookie:

// utils/i18n/localeDetection.ts
import { cookies } from "next/headers";

export function setUserLocale(locale: string) {
  cookies().set("NEXT_LOCALE", locale, {
    maxAge: 365 * 24 * 60 * 60, // 1 año
  });
}

export function getLocale(): string {
  const cookieStore = cookies();
  return cookieStore.get("NEXT_LOCALE")?.value ?? "en";
}

---

Avanzado: Traducciones con Seguridad de Tipos (Type-Safe)

¿Quieres seguridad de tipos? Lingui te cubre:

// En lugar de esto:
t`Hello ${name}`

// Usa el descriptor msg:
import { msg } from "@lingui/core/macro";

const greeting = msg`Hello ${name}`;
const translated = i18n._(greeting);

Tu IDE autocompletará las claves de traducción. Una belleza.

---

Consideraciones de Rendimiento

1. Compilar en Build Time

Lingui compila las traducciones a JSON minificado. Sin sobrecarga de análisis (parsing) en tiempo de ejecución.

// Salida compilada (minificada):
export const messages = JSON.parse('{"ICt8/V":["视频"],"..."}');

2. Pre-cargar Catálogos del Servidor

Carga todos los catálogos una vez al inicio (ver appRouterI18n.ts arriba). Sin I/O de archivos en cada petición.

3. Tamaño del Bundle del Cliente

Envía solo el idioma activo al cliente:

<LinguiClientProvider
  locale={locale}
  messages={allMessages[locale]} // Solo un idioma
>

4. Optimización de Costos de LLM

• Traducciones por lotes: 30 cadenas por llamada a la API.
• Caché de traducciones: No re-traducir cadenas sin cambios.
• Usar modelos más baratos: GPT-4o-mini para idiomas no críticos.

¿Nuestro costo? ~$2-3 dólares por 800+ cadenas × 16 idiomas. Centavos comparado con traductores humanos.

---

La Integración Full Stack

Veamos cómo juega esto con el resto de T3 Turbo:

tRPC con i18n

// server/api/routers/user.ts
import { createTRPCRouter, publicProcedure } from "../trpc";
import { msg } from "@lingui/core/macro";

export const userRouter = createTRPCRouter({
  subscribe: publicProcedure
    .mutation(async ({ ctx }) => {
      // ¡Los errores también se pueden traducir!
      if (!ctx.session?.user) {
        throw new TRPCError({
          code: "UNAUTHORIZED",
          message: ctx.i18n._(msg`You must be logged in`),
        });
      }

      // ... lógica de suscripción
    }),
});

Pasa la instancia i18n a través del contexto:

// server/api/trpc.ts
import { getI18nInstance } from "@/utils/i18n/appRouterI18n";

export const createTRPCContext = async (opts: CreateNextContextOptions) => {
  const locale = getLocale();
  const i18n = getI18nInstance(locale);

  return {
    session: await getServerAuthSession(),
    i18n,
    locale,
  };
};

Base de Datos con Drizzle

Guarda la preferencia de idioma del usuario:

// packages/db/schema/user.ts
import { pgTable, text, varchar } from "drizzle-orm/pg-core";

export const users = pgTable("user", {
  id: varchar("id", { length: 255 }).primaryKey(),
  locale: varchar("locale", { length: 10 }).default("en"),
  // ... otros campos
});

Integración con AI SDK

Traduce respuestas de IA al vuelo:

import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";
import { useLingui } from "@lingui/react/macro";

export function useAIChat() {
  const { i18n } = useLingui();

  const chat = async (prompt: string) => {
    const systemPrompt = i18n._(msg`You are a helpful AI assistant for acme.`);

    return generateText({
      model: openai("gpt-4"),
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: prompt },
      ],
    });
  };

  return { chat };
}

---

Mejores Prácticas que Aprendimos

1. Usa Siempre Macros

// ❌ Mal: Traducción en runtime (no se extrae)
const text = t("Hello world");

// ✅ Bien: Macro (extraído en build time)
const text = t`Hello world`;

2. El Contexto lo es Todo

Añade comentarios para los traductores:

// i18n: This appears in the pricing table header
<Trans>Monthly</Trans>

// i18n: Button to submit payment form
<button>{t`Subscribe Now`}</button>

Lingui extrae estos como notas para el traductor.

3. Maneja los Plurales Correctamente

import { Plural } from "@lingui/react/macro";

<Plural
  value={count}
  one="# credit remaining"
  other="# credits remaining"
/>

Diferentes idiomas tienen diferentes reglas de pluralización. Lingui se encarga de ello.

4. Formato de Fechas/Números

Usa las APIs de Intl:

const date = new Intl.DateTimeFormat(locale, {
  dateStyle: "long",
}).format(new Date());

const price = new Intl.NumberFormat(locale, {
  style: "currency",
  currency: "USD",
}).format(29.99);

5. Soporte RTL

Para árabe, maneja la dirección:

export default function RootLayout({ children }) {
  const locale = getLocale();
  const direction = locale === "ar" ? "rtl" : "ltr";

  return (
    <html lang={locale} dir={direction}>
      <body>{children}</body>
    </html>
  );
}

Añade a la configuración de Tailwind:

module.exports = {
  plugins: [
    require('tailwindcss-rtl'),
  ],
};

Usa clases direccionales:

<div className="ms-4"> {/* margin-start, funciona para LTR y RTL */}

---

Checklist de Despliegue

Antes de lanzar:

• Ejecuta pnpm i18n para asegurar que todas las traducciones estén actualizadas
• Prueba cada idioma en modo producción
• Verifica la persistencia de la cookie de idioma
• Revisa el layout RTL para árabe
• Prueba la UX del selector de idioma
• Añade etiquetas hreflang para SEO
• Configura el enrutamiento basado en idioma si es necesario
• Monitorea los costos de traducción del LLM

---

Los Resultados

Después de implementar este sistema:

• 17 idiomas soportados listos para usar
• ~850 cadenas traducidas automáticamente
• $2-3 costo total por la traducción completa
• Ciclo de actualización de 2 minutos al añadir nuevas cadenas
• Cero trabajo manual de traducción
• Traducciones de alta calidad y conscientes del contexto

Compara eso con:

• Traductores humanos: $0.10-0.30 por palabra = $1,000+
• Servicios tradicionales: Siguen siendo caros, siguen siendo lentos
• Trabajo manual: No escala

---

Por Qué Importa Esto en 2026

Mira, la web es global. Si solo estás lanzando en inglés en 2026, estás dejando atrás al 90% del mundo.

Pero la i18n tradicional es dolorosa. Este enfoque lo hace trivial:

1. Escribe código con macros Trans/t (toma 2 segundos)
2. Ejecuta pnpm i18n (automatizado)
3. Lanza al mundo (profit)

La combinación de la experiencia de desarrollador de Lingui + traducciones impulsadas por LLM cambia las reglas del juego. Obtienes:

• Traducciones con seguridad de tipos
• Cero sobrecarga en runtime
• Extracción automática
• Traducciones IA conscientes del contexto
• Centavos por idioma
• Escala infinitamente

---

Yendo Más Lejos

¿Quieres subir de nivel? Prueba:

Traducción de Contenido Dinámico

Guarda traducciones en tu base de datos:

// packages/db/schema/content.ts
export const blogPosts = pgTable("blog_post", {
  id: varchar("id", { length: 255 }).primaryKey(),
  titleEn: text("title_en"),
  titleZhCn: text("title_zh_cn"),
  titleJa: text("title_ja"),
  // ... etc
});

Auto-traduce al guardar:

import { translateWithLLM } from "@acme/i18n";

export const blogRouter = createTRPCRouter({
  create: protectedProcedure
    .input(z.object({ title: z.string() }))
    .mutation(async ({ input }) => {
      // Traducir a todos los idiomas
      const translations = await Promise.all(
        LOCALES.map(async (locale) => {
          const result = await translateWithLLM(
            [{ msgid: input.title, msgstr: "" }],
            locale
          );
          return [locale, result[0].msgstr];
        })
      );

      await db.insert(blogPosts).values({
        id: generateId(),
        titleEn: input.title,
        ...Object.fromEntries(translations),
      });
    }),
});

Traducciones Proporcionadas por Usuarios

Deja que los usuarios envíen mejores traducciones:

export const i18nRouter = createTRPCRouter({
  suggestTranslation: publicProcedure
    .input(z.object({
      msgid: z.string(),
      locale: z.string(),
      suggestion: z.string(),
    }))
    .mutation(async ({ input }) => {
      await db.insert(translationSuggestions).values(input);

      // Notificar a los mantenedores
      await sendEmail({
        to: "i18n@acme.com",
        subject: `New translation suggestion for ${input.locale}`,
        body: `"${input.msgid}" → "${input.suggestion}"`,
      });
    }),
});

Tests A/B de Traducciones

Prueba qué traducciones convierten mejor:

const variant = await abTest.getVariant("pricing-cta", locale);

const ctaText = variant === "A"
  ? t`Start Your Free Trial`
  : t`Try acme Free`;

---

El Código

Todo esto es código de producción de una app real. La implementación completa está en nuestro monorepo:

t3-acme-app/
├── apps/nextjs/
│   ├── lingui.config.ts
│   ├── src/
│   │   ├── locales/           # Catálogos compilados
│   │   ├── utils/i18n/        # Utilidades i18n
│   │   └── providers/         # LinguiClientProvider
│   └── script/i18n.ts         # Script de traducción
└── packages/i18n/
    └── src/
        ├── translateWithLLM.ts
        ├── enhanceTranslations.ts
        └── utils.ts

---

Pensamientos Finales

Construir una app de IA multilingüe en 2026 ya no es difícil. Las herramientas están aquí:

• Lingui para extracción y runtime
• Claude/GPT para traducción consciente del contexto
• T3 Turbo para la mejor DX del juego

Deja de pagar miles de dólares por traducciones. Deja de limitar tu app al inglés.

Construye globalmente. Lanza rápido. Usa IA.

Así es como lo hacemos en 2026.

---

¿Preguntas? ¿Problemas? Encuéntrame en Twitter o revisa la documentación de Lingui y la documentación del AI SDK.

Ahora ve y lanza esa app multilingüe. El mundo está esperando.