Funciones

Todo lo que hace Lingua. Sin adornos.

Cada línea de esta página corresponde a comportamiento que ya se distribuye en la app de escritorio. Donde todavía no estamos, lo decimos. Los visuales son representaciones HTML de la interfaz real.

01

Lenguajes

Seis runners. Una ventana.

Cada lenguaje tiene su runner con defaults adecuados. JS / TS / Python / Ruby vienen con Lingua. Go y Rust usan las toolchains que ya tienes en tu máquina.

JavaScript

Free

RuntimeWeb Worker · timeouts controlados por el padre

// runs in a sandboxed worker, capped output, instant feedback
const reqs = ['/api/health', '/api/version', '/api/build'];
const probes = await Promise.all(
  reqs.map((u) => fetch(u).then((r) => [u, r.status]))
);
console.table(Object.fromEntries(probes));

TypeScript

Free

Runtimeesbuild-wasm transpila → worker JS

// type-check happens in your editor; runtime is the JS worker
type Tier = 'free' | 'pro' | 'pro_lifetime' | 'team';
const limits: Record<Tier, number | 'unlimited'> = {
  free: 5, pro: 'unlimited', pro_lifetime: 'unlimited', team: 'unlimited',
};
console.log(limits.free); //=> 5

Python

Free

RuntimePyodide v0.29.4 · incluido offline en desktop

# zero install — Pyodide ships inside the binary
import statistics
samples = [42, 51, 39, 47, 55, 38, 49, 44, 52, 46]
print({
    'mean': round(statistics.mean(samples), 2),
    'stdev': round(statistics.stdev(samples), 2),
})

Ruby

Free

RuntimeRuby WASM · Ruby del sistema opcional en desktop

# bundled WASM runs everywhere; desktop can use system Ruby
events = [
  { name: 'build', duration_ms: 184 },
  { name: 'test', duration_ms: 92 },
]
puts events.sort_by { |event| event[:duration_ms] }.map { |event|
  "#{event[:name]}: #{event[:duration_ms]}ms"
}

Go

Pro

RuntimeToolchain local de Go · env mínimo de subprocess

package main

import "fmt"

func main() {
    langs := []string{"js", "ts", "python", "ruby", "go", "rust"}
    fmt.Printf("lingua runs %d languages\n", len(langs))
}

Rust

Pro

RuntimeToolchain local rustc · tmpdir limpio por run

fn main() {
    let langs = ["js", "ts", "python", "ruby", "go", "rust"];
    let total: usize = langs.iter().map(|l| l.len()).sum();
    println!("{} chars across {} langs", total, langs.len());
}
Runtime Node en desktop — cambia cualquier pestaña JS o TS al Node local y obtienes la biblioteca estándar completa (fs, path, http) más require() de cada paquete ya instalado en los node_modules de tu proyecto: el runner sube desde la carpeta del archivo guardado hasta encontrarlos. Node se ejecuta directamente, nunca a través de un shell, con variables de entorno restringidas a una allow-list, timeout del proceso padre y salida acotada. ESM y CJS se detectan solos.

Ruby también se ejecuta hoy (WASM en todas partes, subproceso del sistema en desktop cuando lo prefieres). Java, Kotlin, Scala, Swift, C y C++ están registrados pero todavía no se ejecutan dentro de Lingua. No pretendemos lo contrario.

02

Editor

Monaco, con lo que realmente usas.

El editor que impulsa VS Code, conectado como espera un developer senior: modo Vim que no pelea con la app, paleta de comandos real y atajos personalizables.

  • Monaco editor con resaltado de sintaxis e IntelliSense en cada lenguaje soportado.
  • Vim mode vía monaco-vim — opt-in desde Settings → Editor. Comandos modales, registers, marks y la status line que esperas.
  • Paleta de comandos (⌘ ⇧ P) alcanza cada acción: runners, utilidades, settings y cambio de lenguaje.
  • Atajos personalizados con editor dentro de la app. Exporta e importa como JSON.
  • Depurador JS/TS — puntos de pausa, condiciones, logpoints y watches con step over/into/out. Las expresiones se evalúan sobre una copia acotada de las variables locales, sin eval ni Function.
  • Depurador Python en desktop — breakpoints estándar, step over/into/out, variables locales, call stack y watches mediante CPython/pdb del host.
  • Depurador Go en desktop — breakpoints estándar, step over/into/out, variables locales, call stack y watches mediante Delve/DAP del host.
  • Format on save por lenguaje: prettier / ruff / gofmt / rustfmt donde esté disponible.
snippet.ts probe.py bench.go
⌘ ⏎
— INSERT — TypeScript vimUTF-8 · LF · 2 spaces
format
  • Formatear documento⇧⌥ F
  • Formatear selección⌘ K F
  • Formateador JSONutil
  • Formateador SQLutil
03

Flujo

Snippets, historial y un modelo sano de env.

La infraestructura alrededor del editor evita que un scratchpad se convierta en desorden después de la tercera pestaña.

Historial de ejecución con diff

Cada ejecución se captura localmente. Compara runs consecutivos lado a lado, restaura una versión anterior o borra el historial con un atajo. Los snapshots son opt-in y nunca salen del dispositivo.

Historial de ejecuciónúltimos 2 runs · diff
#42hace 12sok · 1.4 ms
- const tier = 'free';
- console.log(limits[tier]);
  //=> 5
#43ahoraok · 1.2 ms
+ const tier = 'pro';
+ console.log(limits[tier]);
  //=> 'unlimited'
Haz click en un run anterior para restaurarlo. El historial queda local: nunca se transmite.

Variables de entorno en tres capas

Globales abajo, overrides de proyecto en medio y valores de pestaña arriba. La última escritura gana. El env efectivo se calcula al ejecutar: sin herencia oculta ni ruleta de archivos.env.

Variables de entorno3 capas · última escritura gana
1

Global

Disponible para cada snippet en cada proyecto.

  • GITHUB_TOKEN=<redacted>global
  • NODE_ENV=developmentglobal
2

Proyecto

Cargado solo para snippets dentro del root de proyecto activo.

  • API_BASE_URL=https://staging.apiproject
  • NODE_ENV=stagingproyecto (sobrescribe global)
3

Pestaña

Gana. Defínelo inline para el snippet que ejecutas ahora.

  • API_BASE_URL=http://localhost:3000pestaña (sobrescribe proyecto)
Efectivo en runtime: API_BASE_URL=http://localhost:3000, NODE_ENV=staging, GITHUB_TOKEN=<redacted>

Snippets, proyectos y quick-open

  • Snippets — guarda cualquier cosa que deba sobrevivir al cierre de la pestaña. Free limita a 5; Pro quita el límite.
  • Project root — apunta Lingua a una carpeta y quick-open(⌘ P) la indexa en background.
  • Project search — busca por contenido en todo el árbol, limitado al root activo.
  • Pruebas del proyecto — detecta Vitest, Jest, Pytest, Go y Cargo en la app de escritorio, muestra el comando exacto y transmite una salida limitada con opción de detener.
  • Theme presets — importa / exporta tu tema del editor. Vienen tres presets oscuros y uno claro.
  • Importación de playgrounds — revisa enlaces compartidos de TypeScript o Go antes de abrir su fuente en una pestaña; TypeScript se decodifica localmente y Go usa un único endpoint oficial con límites.
04

Utilidades

Los 31 paneles que reemplazan tus tabs del navegador.

Formateador JSON, tester regex, decodificador JWT, hash, parser cron, conversor de color y 25 más. Todo integrado, accesible por teclado y offline.

Utilidades developer

31 paneles integrados.

Las pestañas del navegador que suelen rodear a un runner — formateador JSON, regex, JWT, diff, hash, cron, color y más — ya viven dentro de Lingua.

05

Privacidad y seguridad

Los detalles aburridos que necesitas para confiar.

Lingua ejecuta el código que escribes. Lo tomamos en serio: tanto en lo que nunca recopilamos como en cómo el runtime contiene tus snippets.

Telemetría desactivada por defecto

Nada sale de tu dispositivo hasta que das consentimiento explícito en el prompt inicial. Incluso activada, los payloads son nombres de eventos anónimos con la versión de la app: nunca tu código, nunca rutas de archivos, nunca un vendor de terceros.

Ejecución en sandbox

JS/TS/Python corren en workers con timeouts controlados por el padre y salida limitada. Los subprocesses Go/Rust heredan un env mínimo (PATH, HOME, LANG, TMPDIR). El IPC de filesystem usa un registro de capacidades: el renderer solo toca rutas bajo roots aprobados.

CSP estricta

El renderer desktop trae una CSP que bloquea scripts remotos e imports de módulos no aprobados. Todo lo que Lingua necesita en runtime viene empaquetado, incluidoPyodide v0.29.4, con integridad fijada enruntime-assets.lock.json.

06

Distribución

Builds verificables, licencias offline.

Cada release incluye checksums; las releases públicas de macOS se firman y notarizan, y Windows usa Authenticode cuando hay un certificado configurado. La publicación está bloqueada porpnpm run check:prod-audit. Las licencias se verifican offline: sin conexión al iniciar.

Verificar descarga
$ shasum -a 256 -c SHA256SUMS.txt
Lingua-<version>-mac-arm64.dmg:        OK
Lingua-<version>-mac-x64.dmg:          OK
Lingua-<version>-win-x64.exe:          OK
Lingua-<version>-linux-x86_64.AppImage: OK
Controles de distribución
  • macOSFirma Developer ID y notarización verificadas en releases públicas
  • WindowsSHA-256 · Authenticode cuando hay certificado configurado
  • LinuxAppImage · integridad verificada con SHA-256
  • Canal estable, releases draft-first — las releases se crean como draft, pasan smoke test sobre un build empaquetado y luego se promueven. Ningún binario llega sin ese gate.
  • SHA256SUMS.txt se publica junto a cada release. Verifica antes de instalar.
  • Verificación offline de licencias — los tokens Pro están firmados con Ed25519 y se verifican contra una llave pública embebida. Sin cuenta, sin check de servidor.
  • Auto-updates usan el canal oficial de GitHub Releases y los controles de integridad de cada plataforma. Puedes desactivarlas por instalación.
  • Source-available bajo la Licencia Comercial de Lingua. Compílalo tú mismo si quieres auditar lo que corre en tu máquina.
  • Pipeline de release auditable — cada paso vive en.github/workflows/release.yml en el repo público.

Lánzale tu próximo script de 10 líneas.

Una instalación. Seis lenguajes. Ningún proyecto que crear.