Features

Everything Lingua does. Honestly.

Every line below maps to behavior shipping in the desktop binary today. Where we're not there yet, we say so. Screenshots and short demo videos land with v0.3 — until then, every visual on this page is the actual UI rendered in HTML.

01

Languages

Five runners. One window.

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

JavaScript

Free

Runtime Web 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

Runtime esbuild-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

Runtime Pyodide v0.26.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),
})

Go

Pro

Runtime Local go toolchain · minimal subprocess env

package main

import "fmt"

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

Rust

Pro

Runtime Local rustc toolchain · cleaned tmpdir per run

fn main() {
    let langs = ["js", "ts", "python", "go", "rust"];
    let total: usize = langs.iter().map(|l| l.len()).sum();
    println!("{} chars across {} langs", total, langs.len());
}

Ruby, 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.
  • Format on save per language: prettier / ruff / gofmt / rustfmt where available.
snippet.ts probe.py bench.go
⌘ ⏎
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 history last 2 runs · diff view
#42 12s ago ok · 1.4 ms
- const tier = 'free';
- console.log(limits[tier]);
  //=> 5
#43 just now ok · 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 variables 3 tiers · last write wins
1

Global

Available to every snippet across every project.

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

Project

Loaded only for snippets inside the active project root.

  • API_BASE_URL = https://staging.api project
  • NODE_ENV = staging project (overrides global)
3

Tab

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

  • API_BASE_URL = http://localhost:3000 tab (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.
  • Theme presets — import / export your editor theme. Three dark presets and one light ship in-box.
04

Utilities

The 29 panels that replace your browser tabs.

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

Developer utilities

29 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 — including Pyodide v0.26.4, integrity-pinned in runtime-assets.lock.json.

06

Distribution

Verifiable builds, offline licensing.

Every release is signed, notarized where the OS demands it, checksummed, and gated on a release-blocking npm audit. License keys verify offline — no phone-home check at launch.

Verify your download
$ shasum -a 256 -c SHA256SUMS.txt
Lingua-0.2.1-arm64.zip: OK
Lingua-0.2.1-x64.zip:   OK
LinguaSetup.exe:        OK
lingua_0.2.1_amd64.deb: OK
Signed & notarized
  • macOS Apple Developer ID · notarized · Gatekeeper-clean
  • Windows Authenticode · SmartScreen reputation accruing
  • Linux .deb & .rpm with maintainer signature
  • 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 stay on the same signed channel. 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. Five languages. No project to spin up.