Features

Everything Lingua does. Honestly.

Every line below maps to behavior shipping in the desktop app today. Where we're not there yet, we say so. The visuals are HTML representations of the real interface.

01

Languages

Six runners. One window.

Each language has its own runner with the right defaults. JS / TS / Python / Ruby ship with Lingua. Go and Rust use the toolchains already on your machine.

JavaScript

Free

RuntimeWeb Worker · parent-owned timeouts

// 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 transpile → JS worker

// 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 · vendored offline on 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 · optional system Ruby on 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

RuntimeLocal go toolchain · minimal subprocess env

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

RuntimeLocal rustc toolchain · cleaned tmpdir per 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());
}
Desktop Node runtime — switch any JS or TS tab to local Node and you get the full standard library (fs, path, http) plus require() of every package already installed in your project node_modules: the runner walks up from the saved file to find them. Node is spawned directly, never through a shell, with an allow-listed environment, a parent-owned timeout, and capped output. ESM and CJS are detected for you.

Ruby runs today too (WASM everywhere, a system subprocess on desktop when you prefer it). Java, Kotlin, Scala, Swift, C, and C++ are tracked but not yet runnable from inside Lingua. We don't pretend otherwise.

02

Editor

Monaco, with the things you actually use.

The editor that powers VS Code, wired up the way a senior dev expects: vim mode that doesn't fight the host, a real command palette, customizable shortcuts.

  • Monaco editor with full syntax highlighting and IntelliSense across every supported language.
  • Vim mode via monaco-vim — opt-in from Settings → Editor. Modal commands, registers, marks, and the status line you'd expect.
  • Command palette (⌘ ⇧ P) reaches every action — runners, utilities, settings, language switch.
  • Custom shortcuts with an in-app editor. Export and import as JSON.
  • JS/TS debugger — pause points, conditions, logpoints, and watches with step over/into/out. Expressions evaluate over a bounded copy of locals, without eval or Function.
  • Desktop Python debugger — standard breakpoints, step over/into/out, locals, call stack, and watches through host CPython/pdb.
  • Desktop Go debugger — standard breakpoints, step over/into/out, locals, call stack, and watches through host Delve/DAP.
  • Format on save per language: prettier / ruff / gofmt / rustfmt where available.
snippet.ts probe.py bench.go
⌘ ⏎
— INSERT — TypeScript vimUTF-8 · LF · 2 spaces
format
  • Format Document⇧⌥ F
  • Format Selection⌘ K F
  • JSON Formatterutil
  • SQL Formatterutil
03

Workflow

Snippets, history, and a sane env model.

The plumbing around the editor is what keeps a scratchpad from becoming a mess after the third tab.

Execution history with diff

Every run is captured locally. Compare consecutive runs side-by-side, restore an old version, or clear the history with one keystroke. Snapshots are opt-in and never transmitted off the device.

Execution historylast 2 runs · diff view
#4212s agook · 1.4 ms
- const tier = 'free';
- console.log(limits[tier]);
  //=> 5
#43just nowok · 1.2 ms
+ const tier = 'pro';
+ console.log(limits[tier]);
  //=> 'unlimited'
Click any past run to restore it. History stays local — never transmitted.

Three-tier environment variables

Globals at the bottom, project overrides in the middle, tab values on top. Last write wins. The effective env is computed at run time — no hidden inheritance, no.env file roulette.

Environment variables3 tiers · last write wins
1

Global

Available to every snippet across every project.

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

Project

Loaded only for snippets inside the active project root.

  • API_BASE_URL=https://staging.apiproject
  • NODE_ENV=stagingproject (overrides global)
3

Tab

Wins. Set inline for the snippet you are running right now.

  • API_BASE_URL=http://localhost:3000tab (overrides project)
Effective at runtime: API_BASE_URL=http://localhost:3000, NODE_ENV=staging, GITHUB_TOKEN=<redacted>

Snippets, projects, and quick-open

  • Snippets — save anything that survives the next tab close. Free tier caps at 5; Pro lifts the cap.
  • Project root — point Lingua at a folder and quick-open(⌘ P) indexes it in the background.
  • Project search — find by content across the whole tree, scoped to the active root.
  • Project tests — detect Vitest, Jest, Pytest, Go, and Cargo in the desktop app, inspect the exact command, and stream bounded output with Stop.
  • Theme presets — import / export your editor theme. Three dark presets and one light ship in-box.
  • Playground import — preview shared TypeScript or Go links before opening their source in a tab; TypeScript decodes locally and Go uses one bounded official endpoint.
04

Utilities

The 31 panels that replace your browser tabs.

JSON formatter, regex tester, JWT decoder, hash, cron parser, color converter — and 25 more. All built in, all keyboard-reachable, all offline.

Developer utilities

31 panels, built in.

The browser tabs that usually orbit a code runner — JSON formatter, regex, JWT, diff, hash, cron, color, the lot — already live inside Lingua.

05

Privacy & security

The boring details you need to trust this.

Lingua executes whatever code you write. We take that seriously — both with what we never collect, and with how the runtime contains your snippets.

Telemetry off by default

Nothing leaves your device until you explicitly opt in from the first-run prompt below. Even when on, payloads are anonymous event names with the app version — never your code, never your file paths, never a third-party vendor.

Sandboxed execution

JS/TS/Python run in workers with parent-owned timeouts and capped output. Go/Rust subprocesses inherit a minimal env (PATH, HOME, LANG, TMPDIR). Filesystem IPC uses a capability registry — the renderer can only touch paths under approved roots.

Strict CSP

The desktop renderer ships with a CSP that blocks unapproved remote script and module imports. Anything Lingua needs at runtime is bundled — includingPyodide v0.29.4, integrity-pinned inruntime-assets.lock.json.

06

Distribution

Verifiable builds, offline licensing.

Every release includes checksums; public macOS releases are signed and notarized, and Windows uses Authenticode when a certificate is configured. Publishing is gated bypnpm run check:prod-audit. License keys verify offline — no phone-home check at launch.

Verify your download
$ 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
Distribution checks
  • macOSDeveloper ID signing and notarization verified for public releases
  • WindowsSHA-256 · Authenticode when a certificate is configured
  • LinuxAppImage · integrity verified with SHA-256
  • Stable channel, draft-first releases — releases are drafted, smoke-tested on a packaged build, then promoted. No binary reaches you without that gate.
  • SHA256SUMS.txt ships next to every release. Verify before you install (the snippet on the left).
  • Offline license verification — Pro tokens are Ed25519-signed and verified against an embedded public key. No account, no server check.
  • Auto-updates use the official GitHub Releases channel and each platform's integrity checks. You can disable them per install.
  • Source-available under the Lingua Commercial License. Build it yourself if you want to audit what runs on your machine.
  • Auditable release pipeline — every step lives in.github/workflows/release.yml on the public repo.

Throw your next 10-line script at it.

One install. Six languages. No project to spin up.