Roadmap y changelog

Planeado. En progreso. Publicado.

Una vista curada de hacia dónde va Lingua y qué está mejorando ahora. El historial publicado se genera desde CHANGELOG.md en cada build.

  • 0planeados
  • 1en progreso
  • 35releases estables
1

Dirección

Planeado

Áreas de producto que queremos explorar cuando las bases actuales estén listas.

0
2

En construcción

En progreso

Capacidades útiles hoy, con un siguiente nivel de completitud claramente definido.

1

Distribution

1
  • En progreso

    Signed Windows installer and winget

    Windows builds, installs, and auto-updates from GitHub Releases today, and the winget manifests are generated and validated from published checksums. The remaining step is public Authenticode trust, which removes the SmartScreen warning and unblocks the winget submission.

~

En preparación

Desde v2.3.0

Commits visibles para usuarios que están en main pero aún no se empaquetan en una release estable. Leído directamente desde git log, sin edición de marketing.

12
  1. Fix

    keep the SQL grid in sight on a short result pane

    resultsc4713da

  2. Fix

    keep the header honest after review

    resultsa4c38af

  3. New

    give SQL, HTTP and notebook results one header grammar

    results4f36d27

  4. Fix

    keep run comparisons honest after review

    console6daabe7

  5. New

    draw where the run has been and mark answers that changed

    console6fe07e7

  6. Fix

    keep each run on its own tab in the run meter

    dock3088045

  7. Fix

    count a stopped run in the run meter

    dock03806c2

  8. New

    show run state, time and session runs in a run meter

    dock2b14b39

  9. Fix

    keep the run rail true to what ran

    editorc713ac9

  10. New

    draw the run rail between the line numbers and the code

    editorc90dee3

  11. Fix

    keep answer rows and marks right through edits, scrolling and tab switches

    editor6681166

  12. New

    head the answer column and keep answers whole beside their statements

    editor3eaf3e8

Además hay 143 commits de infraestructura / docs / tests ocultos en esta vista. Revisa el log completo en GitHub.

3

Historial

Publicado

Releases estables en el canal público. Leído desde CHANGELOG.md en cada build; nunca escrito a mano.

35
  1. v2.3.0

    Changed

    • On desktop, Local SQL runs on native DuckDB in its own process: the engine starts faster and large queries finish several times faster with less memory. WebAssembly stays available under Settings › Editor › SQL workspace › Local engine, and takes over when the native engine cannot start. If you already save your SQL tables between sessions, Lingua keeps WebAssembly so they stay in view; choose Native there to switch. The native engine keeps DuckDB's settings fixed, so SET of an option asks you to switch engines.
    • On desktop, pages loaded from files get no extra privileges. Updating straight from a version older than 2.2.0 keeps your saved SQL tables but resets settings, sessions and layouts.

    Fixed

    • Saved Local SQL tables stay writable when their database has no write-ahead log or an empty one. If opening persisted storage fails, Lingua releases its file handles before falling back to memory.
    • Switching projects quickly while Tests stops an old run keeps the latest project's runner and Stop control. An older detection response or error no longer replaces a newer detection of the same project.
    • On desktop, a failed storage copy no longer leaves saved SQL tables beside an unrelated database log. A retry copies the database and its log together.
  2. v2.2.0

    Added

    • On desktop, Settings › Languages shows which Go and Rust binary Run uses, with Choose binary… and Use PATH to go back to the one on PATH.

    Changed

    • On desktop, the app keeps the JavaScript it compiled and reuses it on later launches instead of compiling it again each time. The first launch after updating copies your settings, sessions and saved SQL tables to the app's new storage; the old copy stays, so an older version still opens with it. If that copy fails, Lingua tells you and tries again on the next launch.
    • On desktop, scripts follow the same network rules as in the browser: reading a response from another site needs that site's CORS permission, and fetch can no longer read files on your disk. A local AI server must allow requests from Lingua; Ollama does by default, and LM Studio needs its CORS option on.
    • On desktop, code in the Worker, Pyodide, Ruby WASM and Go can no longer load a script or a font from the network, under any Network from running code setting. Under Block, a dynamic import() of a script URL used to run it anyway.
    • A result from a database connection that is already closed says so in your language, and reading it again keeps failing instead of looking complete.
    • Each SQL query keeps its own undo history, cursor and scroll while you switch between query tabs. Switching used to clear them.
    • An AI endpoint that answers with an HTML page, such as a proxy error or a sign-in wall, shows the page title in the error instead of raw markup.

    Fixed

    • Picking another connection for a SQL query clears that query's results, so a result from the previous connection no longer shows under the new pill.
    • The start page shows the Lingua initials, LG, as Settings › General does, instead of the old RL.
    • Dock tab hints open above the tabs, so the Input hint no longer covers the input set controls.
    • The Explorer header fits more of a long project name, and its tooltip shows the full name above the folder path.
    • The SQL save popover takes focus when it opens from Mod+S or Mod+Shift+S, so Enter saves. Enter used to add a line to the query instead.
    • In the light theme, the guided tour dims the rest of the page; it used to wash it almost white.
    • The italic name of a SQL scratch tab no longer has its last character clipped beside the unsaved dot.
    • In the execution timeline, Page Up or Page Down on the first or last step tints the line and is announced, like the arrows.
    • SQL Save as keeps the text you typed just before it. A quick Save as used to copy the query without its last keystrokes.
    • Running with no file open says so in your language in the Console, and Spanish copy reads Saltar for stepping over in the timeline and herramientas locales instead of toolchain.
    • On desktop, a key that an older build kept in the system keychain for a local AI server, which takes none, is removed the next time the keychain is reachable.
    • Inline values in the editor, from a run or a paused debugger, show bidi, zero-width and control characters as spaces, so a value cannot reorder or hide the code around it.
    • Settings › Editor › Per language names the workflow column Workflow for new tabs, since files opened from an approved folder always start in Run.
    • On desktop, a Go run whose installation lacks wasm_exec.js or cannot read it says so in the Console without printing the Go installation path or the paths it checked.
    • Stop while held HTTP requests replay after the connection returns ends the replay; the requests not sent yet wait for Send now instead of going out one after another.
    • Switches that are off read clearly in both themes: their track now has at least 3:1 contrast against the panel, up from 2:1 in light and 2.5:1 in dark.
    • Run, Debug and Scratchpad are off on the start page, where no tab is open, and the tooltip says to open a file. Run used to stay on and only print No active file to run.
    • On Windows, a Go or Node binary chosen by path joins the existing Path instead of a second PATH entry, so its sibling tools resolve.
  3. v2.1.0

    Changed

    • A chain tag in the HTTP URL reads as its source and path inside the field, response(List repos) · [0].owner.login, while the caret is elsewhere, and opens on click.
    • While paused, the debugger shows the values of the paused line's variables in the Scratchpad's inline pills, and the values a step changed now use the same pills.
    • The desktop app starts with less work: its HTTP client, local MCP server, dialog translations and updater load the first time they are used.
    • Edit with AI's Run preview lists the lines whose inline value changes, as the value before and after the edit.
    • @linguacode/cli and the Homebrew formula move to Node.js 26, the current LTS line. On Node 24, npm warns and the CLI keeps running. A lingua repro envelope still needs the Node major it was packed on, so one packed on Node 24 refuses to run on Node 26 until you pack it again. Contributors and CI read the line from .nvmrc.
    • Out of Labs: Execution timeline (Free keeps the last 20 steps), Run regions, Rich display and its SQL grid magics, HTTP variable scopes, chain tags and snapshot assertions, Compare runs (Pro), Run state, Palette autodetect, GUI actions to code, Pro in context, Clipboard-aware utilities (reads stay off until you turn on Apply from clipboard on panel focus, on Pro), Database connections (Free keeps 3 saved connections; a query saved against a connection now runs on it) Instant SQL (on for everyone on Local, with a switch in Settings › Editor) and Edit table rows (on every plan; a table without a primary key keeps its rowid out of the grid, copies and exports). With nothing experimental left, Settings no longer has a Labs tab.
    • Scratchpad now follows Settings › Editor › Run policy: 500 ms after typing for JavaScript and TypeScript, 1 s for Python, and Manual for Go and Rust, where it used to wait 1.2 s for every language.
    • On Free, Recent runs, Utility pipelines and Run capsules open as slices of your own data instead of locks, and the first upgrade notice in a session opens Compare plans.
    • Turning off Capture code for replay also stops Compare runs from copying code and output; capsules of recent runs still hold their code in memory.
    • Network from running code is always in Settings › Privacy and stays on Allow; a saved Ask or Block now applies.
    • TypeScript tabs no longer underline lingua.display.
    • JavaScript and TypeScript tabs are checked as modules, the way Lingua runs them. TypeScript no longer underlines a top-level await, names the browser also defines such as name or status, or import fs from 'node:fs'. A top-level const lingua is no longer underlined either, and it still fails when run.
    • JavaScript tabs now underline code that always fails, such as a second let with the same name or await outside an async function. They still do not type-check JavaScript.
    • SQL results with more than 30 columns mount only the columns on screen, so fast scrolling holds its frame rate. Their column widths no longer change as you scroll; a long value beyond the rows sampled for width shows an ellipsis, and opening it shows it in full.
    • The desktop app no longer ships its dependencies' source maps and TypeScript files, about 30 MB less inside the app.
    • JavaScript and TypeScript tabs share one language service, which starts when you first type or move the pointer in an editor. Lingua uses less memory, most of all while it sits open untouched.

    Fixed

    • lingua repro review now shows each control's status and the backend's ambient host grants before approval, in human and JSON output, even when a required control cannot be enforced.
    • Turning off Settings › Editor › Inline lint for JavaScript or TypeScript now also removes the editor's own syntax and type errors for that language. It used to clear only Lingua's rules, such as the == warning.
    • A TypeScript tab opened after a JavaScript tab no longer underlines its type annotations as errors.
    • A TypeScript tab opened before you first type in an editor no longer counts its errors twice.
    • Edit table rows: duplicating a row or typing into a cell no longer writes base64 text into a binary column, and a binary cell only takes Set to NULL.
    • Edit table rows: Commit now fails when a row changed since it was read, not only when its key did, for text, whole numbers, decimals and booleans.
    • Edit table rows: running a query or opening another table with changes staged asks before discarding them, and Commit cannot run twice while the table is read again.
    • Edit table rows: switching tabs no longer drops staged changes, closing the window or page asks before losing them, and Shift+Enter opens the value viewer on an editable cell.
    • Edit table rows: SQL Server and Postgres tables whose key a driver cuts or rounds, and MySQL tables without transactions, are read-only; SQL Server no longer counts what triggers write, MySQL rejects a value it would have changed, and clearing a number or date sets NULL.
    • Local SQL accepts CREATE MACRO with untyped parameters, such as CREATE MACRO add_one(a) AS a + 1, and SQL errors now show DuckDB's own reason, with the line and position, instead of one generic sentence.
    • Instant SQL keeps a few rows in sight on a short results pane, and the results below it are one scroll away. It used to show only its column names.
    • Database connections: results, driver errors and secret literals of a query on a connection no longer reach disk or a run capsule. After a reload the query shows ••• in place of the value, and it will not run until you type it again.
    • A connection URL no longer shows its password in the field when the URL does not parse, names it in a parameter, or does not suit the browser. The password moves to its own field.
    • SQL History, snippets and Explain with AI also mask ALTER USER, CREATE ROLE and foreign server passwords written without =.
    • Instant SQL previews work offline and no longer download DuckDB's JSON extension from DuckDB's host, because Lingua ships its own copy. JSON columns and Explain use the same copy.
    • SQL no longer downloads DuckDB's extensions from DuckDB's host. Dates, time zones, collations and Parquet use copies that ship with Lingua, and work offline; on the web, Parquet needs one use online first. A query that needs another extension, such as INET or spatial, fails and names it. now() - INTERVAL 1 DAY and strftime(now(), ...) now work, and so does the 7-day retention of the Free run ledger, which they had silently broken.
    • SQL results stay usable on short windows with the dock open: the rows show first under the status and tabs, the SQL strip and toolbar sit one scroll above them, Load more and Export one scroll below, and staged row edits stay on screen. The editor and results split keeps its 40/60 default there too.
    • SQL History and grid snippets also mask ?api_key=-style parameters, password=x connection strings, values compared to columns named like credentials, and those patterns in comments and quoted names, with SQL Server and SQLite quoting read correctly.
    • Open as JS tab and run capsules keep a variable named like a credential, or holding a JSON Web Token, as a placeholder even if nobody marked it secret.
    • HTTP responses and snapshots saved to disk no longer hold tokens a capture rule surfaced in plain text. Run capsules leave those tokens out too.
    • Variables named like credentials (jwt, auth, session, cookie and similar) and values shaped like a JSON Web Token now count as secret.
    • SQL grid thumbnails skip images whose header states more than 4096 pixels on a side, or no size at all.
    • Arrow keys in the SQL grid scroll a selected cell into view sideways as well as up and down.
  4. v2.0.0

    Added

    • Clipboard-aware utilities (Labs, Pro, with clipboard access allowed in Settings): Utilities classifies the clipboard on this device when it opens and on window focus, names what it found and marks the tools that fit, in the list and on the folded rail. Only the kind is kept. With the same Labs setting, on Pro or on Free with Pro in context and with no clipboard read, any tool's output can go to a pipeline step with Send output to…, and pipeline steps can be disabled, paused with a breakpoint and continued, or re-run with auto-bake.
    • GUI actions to code (Labs): an HTTP request opens as a JavaScript tab that runs in the Worker with its secret variables and recognizable credentials left as placeholders to fill in, the SQL a grid's filters, sort and columns generate saves as a snippet, and a utility pipeline saves as a JavaScript snippet that keeps its steps and never its input.
    • Instant SQL (Labs): on Local, a strip above the SQL results samples the statement under the cursor (1,000 rows) as you type. With the cursor in a CTE it shows that CTE, tints its lines and marks the CTEs and result that read it; a breadcrumb moves the cursor. A newer edit or a Run cancels a stale preview, and writes, remote or computed file reads and side-effect functions never run on their own. A computed column's header opens a breakdown of its sub-expressions with each one's share of NULLs and any zero divisors, and clicking one narrows the rows to those behind it.
    • lingua repro (experimental, source builds): pack wraps a JavaScript Run Capsule and chosen files into a reproduction envelope that denies network and allows only disposable writes, review checks every hash and prints an approval token without running anything, and run runs the reviewed bytes on macOS under Seatbelt (no network, no child processes, reads limited to the staged files) and compares the output exactly with the capsule. It refuses before launch on a stale approval, a different Node.js major, a missing backend or a control it cannot enforce; --json returns the receipt.
    • Tests is a results dock tab in the desktop app, after Terminal, with the number of failed tests on the tab. Run all tests lists every test grouped by file with passed, failed and skipped counts and the line where each failure happened; All / Failed only narrows the list, and Run file and Run this test rerun just that part. It works for Vitest, Jest, Pytest, Go and Cargo, keeps the runner's own log under Show output, and without a project offers Open project folder… and up to three recent projects with the runner each one uses. It replaces the Project tests window. Selecting a failed test opens its file at the assertion with a card under the line: expected against received for Vitest, Jest, Pytest, Cargo and Go when the runner states both, and Run this test again; the card closes with Esc, its close button, or once the test passes.
    • A failing line gets a red tint, an alert mark and, at its end, Copy stack and Add breakpoint. With Pro it also offers Explain, which opens a panel next to the editor that leaves the code editable, names the file and line (Cmd/Ctrl+J jumps back), can be pinned, shows exactly what gets sent and can include the last runtime values, off by default and redacted. Answers offer Apply & re-run, Apply only, Copy, Helpful / Not helpful and suggested follow-ups; the thread stays with the tab in memory.
    • Explain can go to a model on this machine or to your own provider: Settings → Account → AI and the explain panel switch between Local · Ollama and My endpoint, each with its own endpoint and model, and show which model and host will answer. Local needs no API key and now also works in the web app; on desktop, My endpoint goes through Lingua's guarded network proxy, so the provider needs no CORS setting. Existing settings move to the profile their address belongs to.
    • Debugger: breakpoint marks take the shape of their mode (a red dot, an amber diamond for a conditional, a blue ring for a logpoint), and Alt-click in the gutter switches the mode in JavaScript and TypeScript. While paused, the paused line gets its own accent and arrow, the step controls sit right under it, the line you stepped from shows the values that changed, Locals mark new and changed bindings with their previous value on hover, and the Console names the paused line.
    • Database connections (Labs; Turso and Neon also in the browser): the SQL tab can run queries on Postgres, MySQL, SQL Server, ClickHouse, SQLite, Turso, Neon and Cloudflare D1. The connection pill lists Local, your saved connections and session-only ones; New connection takes a pasted URL or the fields, SSL mode and files, and Test connection checks resolve, policy, TCP, TLS, auth and the server step by step, with a copyable report that hides the host, user, database and file. Passwords stay in the system keychain or, if you choose, in memory for the session, and never in files, logs or capsules. Free keeps 3 saved connections and can open more for the session only. A production connection opens read-only behind a red band and asks you to type its name, with an EXPLAIN row estimate, before any write; the server enforces read-only too. On the web the picker explains which engines need the desktop app.
    • On a database connection, the SQL Explorer shows its schemas, tables, views, materialized views, functions, sequences and extensions, read as you open them and kept for the session. Selecting an object shows its columns, keys, indexes, size and DDL in the results area, with Copy DDL, Open data on the connection and SELECT * LIMIT 100. Format, autocomplete and Ask AI use the connection's dialect and schema. On the SQL tab, Cmd/Ctrl+P lists Local's tables and saved queries before files, plus the tables, views and functions of each connection read so far: Enter opens the data, Cmd/Ctrl+Enter the structure and Alt+Enter inserts the name. History shows the runs of the active connection, and saved queries show where they run.
    • Database connections can go through an SSH tunnel: a password, a private key and its passphrase, or the SSH agent, with up to three jump hosts that sign in with the key or the agent. Lingua reads ~/.ssh/known_hosts and ~/.ssh/config without changing them, offers the settings ~/.ssh/config has for the bastion, shows a host key no one knows with its fingerprint to trust once, and refuses a key that changed. Each connection gets its own channel through the tunnel, with no local port. Every connection also gets Confirm every write and Allow private host switches.
    • Manage connections… lists saved database connections by group, with search by name, host, database, group, environment or engine, and Edit, Duplicate, Move to group, Rename group and Delete. Import brings connections in from TablePlus, DBeaver, DataGrip, the open project's .env files or a Lingua export without copying any password: each one that signs in with a password asks for it the first time it connects, and a Keychain connection keeps it once it signs in. Export JSON writes every saved connection without passwords.
    • Edit table rows (Labs, off by default, free): a table opened from the SQL Explorer, on Local or a saved connection, can be edited in the grid. Edit a cell, set NULL, duplicate, delete or add rows, review the SQL and Commit it in one transaction; a change whose row changed since it was read saves nothing. Local tables without a primary key are edited by rowid; views, tables without a key on a connection, and read-only or production connections stay read-only and say why.
    • Copy to Local as table, in Export full result…, turns a connection's result into a Local DuckDB table to join it there with Local data or another connection's copy. It reads the whole result again (or the whole table opened from the Explorer) up to the full export's limits, with progress and Cancel, keeps column types where DuckDB has them, stops on a value its type cannot hold, and leaves no table when cancelled or failed. The Local Explorer shows which connection a copied table came from and when.
    • Database connections reach Turso (libSQL), Neon and Cloudflare D1 over HTTPS. Turso takes the libsql:// URL with its token, or a local server without one; Neon runs on its HTTPS API, so it works where port 5432 is blocked; D1 connects through Cloudflare's API with an account, a database id and a token. In the browser, Turso and Neon open for the tab only and keep the token in memory, never stored; D1 and the other engines still need the desktop app. Turso and Neon keep read-only on the server and take staged edits in one transaction; a read-only D1 connection runs one SELECT, WITH or VALUES statement at a time, and D1 tables stay read-only.
    • Database connections reach SQL Server and ClickHouse. SQL Server takes sqlserver:// or mssql:// URLs, shows its estimated plan for Explain and keeps read-only runs in a transaction that is always rolled back; ClickHouse runs over its HTTP interface with read-only enforced by the server. Both work through SSH tunnels, list their objects in the Explorer and come in through imports; staged edits work on SQL Server, and ClickHouse tables stay read-only.
    • HTTP responses on desktop have a Timing tab that splits the request into DNS, Connect, TLS, Waiting and Download, with any redirects counted apart, and the response header shows how much faster or slower each response was than the previous one. The web build shows the total.
    • HTTP variable scopes (Labs, off by default): collection variables for every request and each request's own Vars tab join the environment, the request winning over the environment and the environment over the collection; on desktop their secret values stay in the system keychain like environment secrets. Each {{variable}} takes the colour of the scope that resolves it, red when none does, and its chip says where the value comes from and what it overrides. An environment can take a colour, red by default for a name like prod, which tints the environment selector, the request's tab strip and Send. When a variable is missing and another environment defines it, Add to {env} copies it in; a secret comes over as its key only, and the environment manager opens on it to type this environment's value.
    • HTTP snapshot assertions (Labs, off by default): a request's response can be kept as a snapshot from the new Snapshot tab, and every later response is diffed against it by JSON path (by line for other bodies), with scrubbers for timestamps, UUIDs, *_id and *Id fields, hostnames and a custom pattern. A response that differs fails the snapshot check in the test results and in pipelines until you Accept it as the new snapshot; Reject keeps the snapshot. Responses also suggest one-click tests: the status, a JSON content type and a few plain fields. A snapshot keeps at most 256 KB of body.
    • HTTP chain tags (Labs, off by default): a {{variable}} that another request captures becomes a tag. Its chip opens the source, the capture path (editable there) and the live value from the source's latest response when it is 2xx, plus when sending: Use last response, Send source first or If older than 5 min. A derived pipeline under the URL shows the chain the tags form, each request with its last status and time, and Run chain sends the sources in order; a chain stops on any status outside 2xx, and a cycle, a chain more than 20 requests deep or a stream source is refused. When two requests capture the same variable, the first in the list wins. When a value a source just returned sets the scheme or host of the next request, Send shows that host and waits for confirmation. Saved pipelines are unchanged.
    • Offline, an HTTP request that needs the internet waits instead of failing: Send reads Queue and send when online, reads go out by themselves when the connection returns, and writes wait for Send now. Local and private hosts, local-only names, streams and pipelines send as before.
    • An HTTP response in JSON opens as a tree with one value per line: fold any node, see each object's and array's size, expand cut-off long strings, and search keys and values with the matching nodes unfolded. Hovering a value offers Capture, which adds a capture rule for its path, and values a rule already captures say so. The tree is a single keyboard stop: arrow keys move and fold, Enter or Space folds or shows a cut value, and C captures.
    • Execution timeline (Labs): Record run, in the Run menu for JavaScript and TypeScript, keeps every statement one run reaches, inside loops and functions too, and the Timeline tab in the Dock replays it: a strip of steps marking console output, errors and the other runs of the selected line; Back out, Back, Next, Over and Out (also on the strip's arrow keys); the line highlighted in the editor with what it changed and which run it is, with the lines it reaches later dimmed; and the variables and call stack as of each step, without running the code again. A move with nowhere to go tints the line red. Up to 5,000 steps per run; Free keeps the last 20.
    • Edit with AI (Pro): from the editor's context menu or the Command Palette, describe a change to the selection (or the whole file) and see it before it lands. Nothing the model wrote runs until Run preview: for JavaScript, TypeScript and Python it runs the redacted file as it is and with the change once, outside the Console and history, without your env vars, with the code's network requests blocked and a 5 s limit, and shows both outputs with badges for errors fixed, new errors and changed output; Show diff compares the whole file. Accept (Cmd/Ctrl+Enter) applies it as one undoable edit, and refuses if the file changed since you asked.
    • Pro in context (Labs): the license pill opens one Compare plans table on Free or in a trial, a trial shows its days left in the pill and in the table (or that it ended), Settings › Account puts the trial under the current plan, the timeline's PRO chip opens the same table, and only the first upgrade notice in a session offers Compare plans. On Free it also opens slices of Pro features: the last 3 recent runs of a tab, utility pipelines that run their first 3 steps, and a PRO chip in the capsule preview.
    • Palette autodetect (Labs): the Command Palette tells a question, a file name and a command apart. A question opens Explain this code, where Include the last run (off by default) adds the tab's output (Pro), a file name opens Quick Open with it typed in, anything else searches commands, and ! first always searches commands.
    • An empty SQL query offers three Ask AI prompts, about your first table when there is one (Pro), and a new HTTP request offers a GET or POST to try or pasting a cURL command.
    • Rich display (Labs): lingua.display(value) in JavaScript and TypeScript, and display(value) in Python, show a value in the Console as a table, image, chart, tree or sandboxed HTML, detected or chosen with { as } (as_= in Python), and lingua.display.progress(label) adds one Console row whose bar redraws in place as the run updates it (Python shows its last value). With it on, the SQL result grid underlines URLs (Cmd/Ctrl+click opens them), draws 0–1 columns as bars and booleans as ✓ or ✗, and shows image BLOBs and image data URLs as thumbnails.
    • Run regions (Labs): // %% (JavaScript, TypeScript) and # %% (Python) lines split a file into regions, listed above the editor. In the editor, Cmd/Ctrl+Enter runs the file up to the end of the region at the cursor and Cmd/Ctrl+Shift+Enter runs all of it; a card under the region shows its output and values, with Insert result as comment and Re-run region. A region that reads stdin with no line left stops there and the card asks for it under the prompt; answers to prompts that ask for a password, key, token, code or PIN, or that have no text, are masked and kept in memory only.
    • Run state (Labs): once you edit after the last run, the editor gets an amber border, inline values dim with their age, the Dock shows Stale and Run pulses. Settings › Editor gets a run policy per language group (On keystroke, On pause or Manual; Manual by default for Go and Rust) that decides when Scratchpad runs.
    • Cmd/Ctrl+. stops a run you started with Run; otherwise the editor keeps it for Quick Fix.
    • Compare runs (Labs, Pro): the Compare dock tab lists your runs by day, with status, file, runtime, duration, a one-line result and the time, SQL and HTTP runs included. Tick any two to see the change in code, stdout, inline values and exit; it opens on the active tab's last two runs. Restore as new tab opens the earlier run in a new tab without running it, and Pin run keeps it past the 50-run cap. The history stays in memory for the session.
    • When Go or Rust is missing on the desktop app, a Go or Rust tab disables Run (Scratchpad does not auto-run either) and shows an empty state in the Console, opened the first time in a session, that names where Lingua looked, with Installation guide, Choose binary… and Detect again; editing stays available. Choose binary keeps a go or rustc executable after checking its name and version. Lingua also looks in the usual install folders (/usr/local/go/bin, ~/go/bin, ~/.cargo/bin, Homebrew), so an app opened from the Dock finds a toolchain its PATH lacks.

    Changed

    • The first-run tour points at the real control: the card says which step of three you are on, has an arrow to the highlighted control, dims the rest without blurring it, and the editor step lights the code area only. Back and the step's action come first and Skip tour last.
    • Run capsules (Cmd/Ctrl+Alt+C) explains what a capsule is and opens as a list with a detail pane. Each row shows the language, name, when it ran and its result; search looks at names, languages and code, and All / OK / Errors narrows the list, timeouts and stopped runs counting as errors. The selected capsule shows its code, input and output, with the runner, hash and environment folded under Run details; Open puts it in a tab without running it, Share holds Export, Export HTML and Copy summary, and More holds Compare with…, Create Capsule Workspace, Prepare regression case and Remove. A capsule opened from Import is listed for the session as not run. On Free the dialog previews your own last run read-only, says how many of the 5 kept runs you have, and keeps Import. Settings › Privacy › Clear everything also clears imported capsules.
    • Notices show one at a time in a row above the status bar instead of a toast over the editor, the dock or the welcome templates. A notice that asks for a decision (restore last session, a missing toolchain, a file changed on disk, an HTTP chain confirmation) waits for an answer; the rest leave after 8 s. Others queue behind them by priority instead of replacing them, and each Pro feature shows its upgrade offer once a session; later blocks of the same feature still say why without the offer.
    • Files opened from an approved folder (Explorer, Quick Open, project search, the Tests tab, deep links, templates) start in Run mode, so Scratchpad no longer executes a module on its own the moment it opens. New tabs and File › Open… keep the per-language default.
    • The Explorer header keeps New file and New folder, and moves Collapse all folders, the project tests and terminal actions, Refresh and Export project as zip into a ⋯ menu, so the project name fits.
    • Less filler text: Settings sections, the empty editor, the Console, Utilities, the Command Palette, Quick Open, SQL and HTTP empty states, What's New and several dialogs drop taglines and hints that restated their labels. Settings loses its footer bar and Esc chip; commands in the palette show a second line only when it states a requirement or status. Settings search still finds rows by those words.
    • Selected and highlighted rows no longer draw a coloured strip on their left edge. The Settings rail, the Explorer's open file, SQL queries, history and explorer objects, the slowest plan step, the next input line and the active notebook cell use a background tint and heavier text instead; Compare tints changed rows by kind.
    • Settings › Privacy lists each AI send with where it went and no content, and its AI row now reads enabled once a model is set, plus a key for My endpoint. PRIVACY.md explains what each AI feature sends and where, for Local and for My endpoint.
    • HTTP Send explains why it is off: a hint under the URL says to enter a URL, to give a missing variable a value, or to use a full URL with its scheme, and Send and Cmd/Ctrl+Enter wait until the URL is valid once its variables are filled in. The URL highlights each {{variable}}, red when the active environment lacks it, its placeholder reads as a placeholder, and the Auth tab shows the scheme in use.
    • The HTTP request list and response history mark the selected row with its background and weight instead of a coloured strip on its left edge.
    • The interface now ships the Inter font it always declared, so text no longer falls back to the system font, including offline.
    • Appearance offers Dark, Light and System. System follows the operating system's light or dark setting, and each card's preview uses that theme's real shell and editor colours.
    • Buttons share one set of states: a small lift on hover, a pressed state, a two-pixel focus ring in the control's colour, and the same faded look when disabled. Run and the main action on each surface use the accent colour; destructive buttons stay red text until a confirmation asks for them. Settings switches are smaller (36 by 20 pixels).
    • Animations and transitions use the shared timing tokens and stop when the system asks to reduce motion.
    • The workspace has one 48-pixel command bar instead of a title row plus a floating pill: file, language, engine, Run, the command icons, license and Settings sit in the same row, and the editor starts higher. On SQL, HTTP and Utilities tabs the bar keeps only the workspace chip, since Run and Send live in the tab. Undock in the More actions menu brings the draggable pill back, and Dock returns it.
    • The empty results column next to the editor is gone. Console, Input, Compare, Variables and Terminal (desktop, with a project open) share one results dock under a full-width editor; each tab beyond Console shows up once it applies, as do Debugger, Browser preview, Dependencies, Git diff and Recipe. The dock's tab row carries auto-log, run history, time, capsule export and share, and hiding the dock (Cmd/Ctrl+\) folds it to that row. The dock is open by default.
    • Compare is a dock tab with a one-line header and a full-width diff; Cmd/Ctrl+Shift+D opens and closes it. The Console tab ends with bars for the last five runs.
    • The Input drawer puts stdin lines and arguments side by side, with the input-set controls in its header, so nothing is cut off at the default height. The Input tab shows how many lines are staged.
    • Variables open in the results dock by default; Settings still offers the floating card. Existing installs move to the dock once.
    • Validation and view-only files show their report at the top of the Console tab.
    • Run gives a short press response and one accent sweep down the editor per completed run, and switching dock tabs cross-fades the body; all of it is off when the system asks to reduce motion.
    • The command palette groups results under Recent, Workspaces, Actions, Utilities, Templates and Snippets, shows each command's shortcut as a keycap on the right instead of inside its description, and jumps between groups with Tab and Shift+Tab. Recent leads while the search is empty; while filtering, groups follow their best match and each command appears once. The palette opens over a light veil so the app stays readable behind it.
    • The Utilities tab folds its tool list to a 56 px icon rail (search, favorites, the six categories, Pipelines) so the open tool gets the width; Cmd/Ctrl+B on a Utilities tab opens and closes the compact list, which shows the tool count in its footer, and Cmd/Ctrl+K opens it with search focused.
    • The JWT Debugger dates each time claim in UTC at the end of its line and badges exp, nbf and iat with how far they are from now, flagging an expired token or one that is not valid yet.
    • The Regex Tester mirrors its flags field in g, i, m, s, u and y chips, and explains the pattern token by token with a local parser, without any network request.
    • Settings tab shortcuts follow the rail from top to bottom: Cmd/Ctrl+1 General, 2 Appearance, 3 Editor, 4 Languages, 5 Environment, 6 Privacy, 7 Account, 8 Integrations, 9 Shortcuts and 0 Recovery; Plugins and Labs have no number. The old numbers for Languages (8), Environment (4), Privacy (9), Account (5), Shortcuts (6) and Plugins (7) no longer apply. Languages, Integrations and Recovery get braces, plug and life-buoy icons.
    • Settings rows are denser: hints wrap at 70 characters, controls sit on the right with 30-pixel selects, and a tab with several sections shows chips that jump to a section and follow the scroll. Pro-only rows show a Pro lock badge and an Unlock in Pro link instead of a disabled control or a full button.
    • Settings → Editor puts the default workflow, auto-log and execution timeout in one Per-language defaults grid (JavaScript, TypeScript, Python, Go and Ruby; a dash marks a setting a language does not have), and Theme preset moves to the end of the tab.
    • Settings → Privacy is split into Privacy + Trust, Run Ledger, Local data, Network activity, Recent activity and Redaction preview. Local data opens with a total for the stores, the SQL workspace database and the run capsules in memory, a Reveal folder button on desktop, and Clear everything…, which clears your settings, snippets, utility history, trust feed, SQL queries and run History, and license token, the SQL workspace database (including the Run Ledger) and the capsules after one confirmation that warns about the license; HTTP requests, notebooks and the open session are kept. Clearing a store also resets its live copy, so the next change cannot write the cleared data back.
    • Settings has a Labs tab for experimental features, each off by default. Its first one adds Network from running code to Settings › Privacy: Allow, Ask or Block for code in the JavaScript worker, Pyodide and Ruby WASM. Ask confirms each host once per tab while the run waits, Block refuses the request with a message that names the host, and both are logged in Recent activity. Privacy also shows where the AI features send their prompt, with a link to Account › AI assistance.
    • The SQL tab is laid out like a database client. A connection bar names Local · DuckDB and holds Import data; the Explorer lists Local's schemas with Tables, Views and Macros, each table's row count, the format it was imported from and its column types, with Filter objects, Collapse all and a drop target that appears while a file is dragged over it. Cmd/Ctrl+B folds the Explorer to a 44 px rail. With no tables, Try a sample table creates a small cities table and opens a SELECT over it. The Run Ledger schema no longer shows in the tree; its tables still autocomplete.
    • SQL results sit under the editor, below a strip naming the SQL that produced them. Clicking a table in the Explorer shows its rows with the generated SELECT and Edit in editor. Profile is a results tab instead of a drawer, numbers align right by their DuckDB type, null reads in italics, and Cmd/Ctrl+C copies the selected row as JSON.
    • Export full result… replaces the Export menu and the copy icons: one dialog writes CSV, TSV, JSON, Markdown or SQL INSERT to a file or the clipboard, says how many rows the result holds (at least how many when it stopped at the row window), and adds Save as table, Send to Python tab (up to 1,000 rows as dicts) and Save as run capsule.
    • SQL queries open as tabs inside the SQL tab. New queries start as scratches, which ask to be saved or discarded when closed; Cmd/Ctrl+S saves one with a name and a folder, and Cmd/Ctrl+Shift+S saves a copy. The Explorer lists Scratches, then Saved queries by folder. Existing queries become saved queries without a folder, and only the one that was open comes back as a tab. On Free, each query tab counts toward the 3 open tabs.
    • SQL Run is split: Run and Cmd/Ctrl+Enter run the statement under the cursor, Cmd/Ctrl+Alt+Enter runs the selection, Cmd/Ctrl+Shift+Enter runs every statement with one result tab each plus Messages, and a gutter button runs one statement. The editor header counts the statements and names the one holding the cursor. Running several statements stops at the first one that fails.
    • Cancel (Cmd/Ctrl+.) stops a running SQL statement with a new Cancelled status, and a statement past the time limit is stopped the same way; if DuckDB keeps running after 5 seconds, Restart the SQL engine stops it. Results stream up to the 10,000-row window and show the total as at least that many instead of reading every row.
    • Explain opens a Plan tab with the operator tree, a time bar and row count per operator, the slowest one highlighted, the total time and Copy plan as text. Anything other than a single SELECT, including statements that write, gets the estimated plan, since the analyzed one would run them.
    • The SQL Explorer keeps a History of the last 200 runs on this device (status, time, duration and the SQL with credentials masked, never the rows), with Search SQL, Clear history and a click that opens a run's SQL in a new scratch.
    • The SQL result grid mounts only the rows on screen and adds Load more, which pages through the result and then keeps reading the same stream without running the query again, up to 100,000 rows, four million cells or 256 MB for the session. Filter rows, column conditions, a sort chip and a column picker work on the loaded rows, and the strip below shows the same view as SQL with Apply to query.
    • Right-clicking a SQL cell filters by it, excludes it, copies the value, the row as JSON or the row as INSERT, or opens the value viewer, which pretty-prints JSON and shows a BLOB's size, an image preview and its hex. Foreign-key cells of a table opened from the Explorer link to the referenced row, with back to the table and Referenced by counts.
    • A column rail beside the SQL grid summarizes each column from the loaded rows (null share, distinct count, range, a histogram or the top values), and a click inserts that value or range as a condition at the editor cursor.
    • Export full result… adds NDJSON, XLSX and Parquet, and can write every row of a windowed result by running its query again with the grid's conditions, sort and columns, with progress and Cancel. Copy to clipboard takes up to 10,000 loaded rows in a text format.
    • Import data can add a file's rows to an existing table, mapping each column onto one of its columns or skipping it, and a CSV chooses its header row and delimiter. The rows go in one transaction, so a row that does not fit adds nothing.

    Fixed

    • One upsell pitch shows per session while later blocked actions still answer at once, and the active SQL query tab carries its connection's environment colour.
    • Shared controls show the same focus gap and ring as buttons, and icon buttons a pressed state.
    • Utility pipelines keep their controls reachable beside the expanded tool list: the columns follow the panel's width and stack when it is narrow, instead of sliding under Results.
    • A utility pipeline step that blocks its worker, such as a catastrophic regex, now times out after 30 seconds instead of hanging until the app reloads, and closing the panel stops a run in progress.
    • An SSH tunnel that fails before sign-in, such as a port that accepts the connection and never answers, or a refused sign-in or host key followed by a reset, reports its error and leaves your other database connections open, instead of stopping the SQL host and everything running in it.
    • In the web app, a SQL tab that finishes loading its engine no longer replaces the open query tabs another browser tab just saved, so reloading that tab keeps them. A tab now saves a store only when something in it changed.
    • With the browser blocking site data, Lingua says that nothing is saved after a reload: the toolbar shows not saved instead of autosave, a warning appears on load, and the browser asks before a reload drops edits. The guided tour no longer reopens on every load, and pasting a license again after a reload keeps one web seat instead of using up all three.
    • Lingua on the web boots and runs when the browser blocks site storage, as block-all-cookies does, instead of stopping at a blank page. Settings and work stay in memory and are gone on reload.
    • Pasting a hostname or a version such as www.example.com or 1.2.3 no longer suggests the JWT Debugger; the first segment has to be a JWT header.
    • The HTML entity decode step in utility pipelines leaves &constructor; and other names it does not know as written, instead of printing JavaScript source in their place.
    • Local DuckDB results show Infinity, -Infinity and NaN instead of null, right-aligned as numbers. A real NULL still shows null, and column stats count only those as null. The grid's sort and number filters put these values where DuckDB does, the column rail's range names them, and Python handoff writes them as float(...). Results saved before this change keep the null they were saved with. A full JSON or NDJSON export now quotes them, since DuckDB writes them bare and no JSON parser reads that.
    • Cmd/Ctrl+Enter inside the code editor runs or stops the file, as documented, instead of inserting a line below the cursor.
    • Opening a capsule from Import, the capsules browser or a Capsule Workspace file starts the tab in Run mode, so its code waits for Run. JavaScript, TypeScript, Python, Go and Rust capsules used to open in Scratchpad and run on their own a second later.
    • Utilities keeps unfinished inputs when switching between vertical, horizontal and editor-only layouts; drafts still clear when the Utilities tab closes or the app reloads.
    • Running one Vitest file or test now selects that exact file, so a matching path in a nested project or a longer filename cannot run alongside it.
    • A scoped test rerun now keeps file and build failures visible, opens their output, and labels retained historical results as not run instead of counting old passes as current results.
    • The Tests empty state now offers Detect again after adding a test configuration to the open project, without reopening the folder or running tests automatically.
    • When Explain this error fails on its first request, Retry shows What gets sent again with the current code, and reopening the panel offers Send instead of an empty conversation.
    • The HTTP workspace no longer shows Sending request… when no request is selected, a device seen with a clock ahead no longer reads as seen in the future, and Plugins → Refresh is off in the web app, which has no plugin folder.
    • Loading more rows of a SQL result that another run replaced reports an error instead of silently ending the partial result, on desktop as on the web.
    • Web database connections remember Cancel during the initial handshake and do not dispatch that run afterward.
    • On the web, a database token you just replaced is no longer forgotten when an older request with the previous token fails to authenticate.
    • Long values in an HTTP response body no longer wrap back to the first column and break the indentation: Wrap is off by default, and when it is on, a wrapped value stays at its own indent.
    • SQL results show LIST and STRUCT columns as arrays and objects instead of Arrow internals.
    • Run Ledger toggle, export and clear events now appear in Privacy › Recent activity; they were dropped before they reached the feed.
    • Language chips and labels in the light theme are readable (they were pale text on pale tints).
    • On desktop, the first query after cancelling or timing out a long SQL query no longer fails with The SQL host stopped.
    • The Cron Parser's schedule field is no longer cut off at narrow window widths, since the tool list folds to a rail.
    • Disabled primary buttons such as Save set, Save Snippet and Start free trial keep readable text instead of white on pale blue.
    • Danger-coloured text that rendered without a colour now uses the error colour.
    • Settings selects given a custom width, such as the execution timeout ones, keep their styling instead of rendering as plain browser selects.
    • Run, HTTP, SQL and pipeline capsules recorded in the desktop app now say desktop instead of web.
    • HTTP requests queued during an earlier reconnect send resume when it finishes; queued writes still wait for Send now.
    • Fast typing in the SQL editor no longer drops keystrokes or saves an older draft; Run and Format use the newest text.
    • Undo in a SQL query no longer reverts what you typed in another query with the same text.
    • The HTTP response header keeps its timing and size on one line; a long status text is shortened first.
    • Quick Open describes an unsaved tab as "Unsaved · edited 2 min ago" instead of showing its internal id, and shows the project-relative path for files on disk.
    • SQL result columns are labeled with DuckDB type names (VARCHAR, INTEGER, DECIMAL(6,2)), the same names the column profile uses; the Arrow name is in the tooltip.

    Security

    • On desktop, under Ask and Block in Network from running code, fetch and XMLHttpRequest in the Worker, Pyodide and Ruby WASM refuse local files outside the app. They read any local file before. Allow, the default, is unchanged, and a dynamic import() can still load a local .js, .mjs or .json file; USAGE explains what these runtimes can reach on desktop.
    • The desktop local MCP server moves to the patched @modelcontextprotocol packages (server 2.3.1, node 2.1.1), which fix one HTTP client's messages reaching another on a shared transport and a request that could exhaust memory during validation.
    • On desktop, the AI API key and HTTP environment values marked secret are encrypted with the system keychain instead of being stored in plain text. Existing values move on first launch, and a value stays where it was if the move fails. Without a system keyring, as on Linux sessions that report the basic_text backend, they stay in local storage as before and Settings says they are not encrypted. The web app keeps them in browser storage and now says so next to the field.
    • The desktop app moves to patched zod 4.6.7 (memory exhaustion on oversized collections, through the local MCP server), undici 8.12.3 (a crash on excessive content encodings, in the HTTP proxy) and @azure/msal-node 7.1.1 (through the SQL Server driver, whose Azure sign-in Lingua does not use).
    • On MySQL and ClickHouse connections, the write check and the History read SQL by that server's own quoting rules. A comment, string or name that the shared Postgres-style reading missed can no longer hide a write such as INTO OUTFILE from the typed-name confirm on production and Confirm every write connections. History now masks MySQL passwords in double quotes or with escaped quotes, and ClickHouse heredocs, instead of keeping all or part of them. On MySQL, locking reads, variable assignments and named locks also ask first.
    • Desktop builds run Electron 44.9.1 instead of 44.3.0, with Chromium 152.0.7977.167 and the mitigation for the compromised eMudhra intermediate certificates (GHSA-jr5w-w6x2-84p9).
    • In the web app, settings, AI configuration, snippets, environment variables, the trust log, utility history and favorites, SQL queries and HTTP requests now reach your other open tabs. Turning off analytics, removing an API key or clearing a store in one tab applies in the others right away. Before, another tab kept the old copy and its next change restored it. Each tab keeps its own open queries, active request and any history that is not saved.
  5. v1.6.2

    Fixed

    • A desktop or web build that cannot verify your license token, such as an older version opened after a signing-key rotation or a stale cached web app, no longer deletes it. The license shows as rejected with its reason, grants nothing in that build, and is back on the next launch of a build that trusts it. The same holds when the license server does not recognize the token or its signature. Privacy & Trust now lists each rejection.
    • Development and locally packaged desktop builds keep their data in separate Lingua Dev and Lingua Local folders, so they can no longer change the installed app's license, consent or approvals, and they no longer take over lingua:// links.
  6. v1.6.1

    Fixed

    • Lua string.format with a zero %g precision, such as %.0g, now formats like standard Lua instead of failing the run with a meaningless error.
    • lingua capsule verify and the regression-suite export name the engine mismatch for Python, Go and web Ruby recordings. A real recording with per-line results or a failed run used to report a generic incomplete baseline instead.
    • Desktop HTTP, SSE and WebSocket requests honor Stop and their timeout while the host name is still resolving, instead of waiting on a DNS lookup that never answers. A WebSocket header named __proto__ is now sent like any other header.
    • Python print with several arguments shows strings in the console as print does, without repr quotes (sum = 55, not 'sum =' 55). Strings inside lists and other containers keep their quotes.
    • A language-changing Save As no longer leaves a recipe bound in the background when the binding was made while the file was still writing.
    • Starting the guided tour opens the console only once the tour actually begins; a start interrupted by another dialog leaves the bottom panel as it was.
    • The web app no longer logs a Content Security Policy error on every load from a script Cloudflare injected into the page.
  7. v1.6.0

    Added

    • Capsule Workspace imports recompute attached-file SHA-256 hashes locally and distinguish matching, mismatched, and unverified text without executing code.
    • Manual notebook project documents. Open, Save and Save As preserve .linguanb v1 cells and output evidence; capability-backed writes detect changed files and retain unsaved edits.
    • Explicit current-file Capsule verification and bounded serial suite v1 with strict per-case verdicts, unchanged baselines, in-root target validation and inert project-target export/inspection.
    • Run Capsules support strict CLI verification. The new verify command rejects drift and incomplete evidence with nonzero exits, treats Python, Go and web Ruby recordings as inconclusive because their app engine differs from the CLI, while validate stays inert and replay keeps its original exit contract.
    • Go/Rust project definition and references use server-declared capabilities and capability-authorized destinations, preserving dirty buffers and rejecting stale responses.

    Fixed

    • Saving a file no longer reverts stdin, named inputs, workflow or one-shot timeout changes made while the save was still writing. Timed-out or stopped CLI runs and native dependency installs now force-stop their remaining process group and no longer hang on output held open by an escaped background process.
    • A guided tour interrupted while loading or waiting for the editor no longer opens over a newer dialog or closes it when the delayed load finishes. Explicit retry still works.
    • Utility pipeline import rejects malformed steps instead of silently saving a shorter recipe. Failed imports preserve the existing library and pasted JSON for correction.
    • URL parsing in utility pipelines and the CLI preserves query names such as __proto__, constructor and toString, including repeated values, instead of dropping them or adding nonexistent values.
    • Long inline results keep their reserved row while the next run is in flight, so the code below no longer jumps on every automatic run. Rows the finished run does not reuse are released when it ends. Shown results now follow their source line through edits until the next run, instead of staying on the line number that run reported.
    • A native dependency install whose installer already exited no longer waits out the five-minute deadline when a leftover helper holds its output open; it settles by the installer's exit code. A timed-out Rust debugger compile keeps the timeout reason even when compiler output fills the diagnostics budget.
    • Native-run capture, Go and Rust debugger compile diagnostics, and Go/Rust/Ruby dependency-install logs honor their UTF-8 byte budgets, including truncation markers, without splitting multibyte characters.
    • Release downloads separate desktop apps from terminal tools, and explicit Windows/Linux ZIP targets keep their platform. The guided tour explains automatic Scratchpad runs and leaves console feedback illuminated; long inline results reserve space below source instead of covering it. Unnamed asynchronous worker stack frames join the existing collapsed runtime details.
    • The desktop HTTP and WebSocket private-network guard now also blocks NAT64, 6to4 and IPv4-translated IPv6 addresses that point at loopback, private or cloud-metadata IPv4, plus Teredo, benchmarking, site-local, documentation, discard-only and other reserved IPv6 ranges and localhost., while NAT64 addresses of public hosts keep working.
    • Full app review sweep. Filesystem: New File no longer truncates an existing file, web rename no longer deletes or corrupts files, renames refuse to overwrite siblings, and reopening a file through a symlinked folder can no longer escape the project. Runs: results stay on the tab that ran them, notebook cells and editor runs no longer stop each other, Stop works for recipes and during Ruby detection, console streaming honors output caps, and the Run/Debug/Scratchpad choice survives a restart. Desktop: Go/Rust language servers are not leaked on project switches, applying a license during startup keeps the new token, reloads and quits clean up terminals, installs and debug sessions, and lingua://license email links prefill the token. CLI: annotated TypeScript capsules replay on Node 24, large sources and dash-leading arguments work, repeated signals stop the child, and a piped stdin that never closes times out instead of hanging without eating into the program's own --timeout. UI: shortcut hints follow the platform and user overrides, nested dialogs close one at a time, in-layout dialogs cover the action pill, failed saves explain themselves, and the Recipes catalog no longer ships in the startup bundle. SQL: DATE, TIMESTAMP and DECIMAL results (including every SUM) render as values instead of epoch numbers or word arrays, long profile aggregates are rounded, and the profile action survives hiding the bottom panel. AI answers keep their list numbering around code blocks.
    • Workspace runs and copy polish. Mod+Enter and the action pill now run the active SQL query, send the HTTP request, or apply the selected utility, even with focus on a button. AI explanations answer in the interface language. HTTP request controls and Settings rows return to their 32 px height, and short Spanish action labels use the infinitive consistently. Social previews ship real PNG cards per page and locale, and the landing tour shows Spanish captures on the Spanish site.
    • Raised the transitive undici 7.x security floor to 7.29.1 in all independently locked projects.
    • AI responses have bounded size and duration. JSON and streaming answers stop at resource limits, cancel cleanly, and never save a clipped answer as complete. English and Spanish notices explain limits and deadlines.
    • Ordinary desktop windows no longer disable session recovery merely because the optional smoke bridge is present.
    • Do not queue a Go/Rust destination selection when a stale file open was refused.
    • Handle Monaco delayed-task cancellation when model handoff or reference widgets dispose, without suppressing unexpected errors.
  8. v1.5.1

    Added

    • Selected code can travel with a safe reference. Copy reference and Copy with context are Free editor and modified-diff actions that require an explicit selection, use a relative file name, and never copy hidden content or an absolute path.
    • A Run Capsule can move from the app to the CLI. Export the latest run as JSON in Free, inspect it, validate it without execution, then explicitly replay trusted source to compare status and output. A deterministic example and English/Spanish walkthrough document the boundary.
    • Runtime availability is explained where actions are chosen. Menus, the command palette, and Settings distinguish browser limitations, license gates, and missing local Node, Go, Rust, Deno, Bun, or Ruby installations instead of treating payment as an installation step.

    Changed

    • Dead-code checks now cover every independently locked package. CI analyzes the root app, website, license Worker and update Worker with explicit package boundaries, proves each boundary with a temporary negative fixture, and runs for stacked pull requests as well as pull requests targeting main.
    • Desktop filesystem IPC now validates wire payloads before side effects. File operations, project search and replace, bundle import/export, capability lifecycle and watchers reject malformed types, tuples and oversized text at a shared runtime boundary while preserving the typed preload and web API.
    • Import Preview no longer reads the clipboard when it opens. Paste, file selection and drag-and-drop remain explicit; obsolete Import Preview consent and an unused inspector-default setting are ignored on rehydrate without resetting other preferences.
    • Release evidence is easier to reproduce and review. The website now links an English/Spanish run-to-capsule walkthrough, and the release gates verify mirrored web-runtime bytes, Linux updater metadata, and package-specific dead code. Production signing and live installation remain separate release checks.

    Security

    • Production web and desktop shells block arbitrary inline scripts. Only the exact prepaint bootstrap is hash-authorized; Browser preview and rich HTML retain script support in separately governed opaque sandboxes with cancelable, source-checked document loading.
    • The desktop window navigates only to its own renderer document. Other local files, same-origin server documents and query variants are rejected, including redirects; normal reload and fragments remain supported.
    • Git inspection no longer runs configured filesystem-monitor hooks, filter drivers or external diff helpers. Repository status and comparisons use isolated Git configuration and environment settings, keeping only your trusted safe.directory, line-ending and global ignore settings. Normal repositories, submodules and linked worktrees remain supported; Git 2.36 or later is required.
    • Project bundles cannot import repository metadata. Archives containing .git entries or filesystem aliases are rejected before a destination is selected or files are written.
    • Local MCP secret exclusions apply through symlink aliases. File reads, directory listings and search check both requested and canonical paths while preserving permitted in-project symlinks. MCP remains read-only.

    Fixed

    • Run and Stop controls stay reachable and accurately named. Narrow editor tabs reserve space for the action pill, overflow actions remain accessible, and the controls reclamp after resizing, zoom, locale changes, or restored positions.
    • Console, Browser preview, and SQL failures have recoverable paths. Incoming output respects manual scroll, preview promise failures are reported, retained preview documents stay isolated by tab, and SQL explains how to retry an engine failure without reloading the whole app.
    • Theme contrast and stale results are guarded. Light and dark editor themes meet measured contrast checks, and disposed notebook sessions cannot publish late output into a replacement session.
    • Stop now cancels Node, Ruby, Deno and Bun version checks at their source. Hung runtime shims and their descendants are terminated during preparation, output is bounded, and a cancelled check cannot execute code or poison the next run.
    • Python, Go and Rust Debug can now be stopped before a debugger session exists. Stop, window closure and app shutdown cancel authorization, source staging, tool discovery and Rust compilation; cancelled probes and compilers clean up their process trees, and late work cannot replace a newer debug run.
    • Native debugger Stop cancels adapter startup and connection. Late adapters cannot launch after cancellation, failed handshakes clean up their resources, and closed transports no longer deliver stale events. Missing LLDB executables surface as errors rather than uncaught child-process failures.
    • Stopping Python or native DAP debugging reaps remaining descendants after the adapter exits. Failed Delve startup also cleans its tree on timeout, early exit or connection failure.
    • Stop and timeout clean up native descendants even when their parent exits first. A descendant with independent pipes that ignores graceful termination no longer escapes cleanup when the parent closes.
    • Go Stop also cancels toolchain discovery and compilation. Late compiler responses and old worker messages cannot start or stop a newer execution; compilation timeouts are distinct from WASM execution timeouts.
    • Rust Stop cancels runtime detection, compilation and the native binary. Closing the owning window cancels the same pipeline; late replies cannot replace a newer run, and timeouts have a distinct status.
    • Closing a desktop window cancels its Node, Ruby, Deno and Bun runs, including preparation. App shutdown force-stops remaining native children instead of relying on timers after exit; other windows and later runs remain independent.
    • Project tests honor Stop and window closure while authorizing the folder or detecting the framework. Preparing runs cannot bypass the one-suite-per-project limit, and late cleanup or output cannot affect another run.
    • Ruby, Deno and Bun also honor Stop during runtime discovery and source staging. Late preparation cannot execute cancelled source or replace another run's Stop owner, and temporary files are cleaned before completion.
    • Stop also takes effect while the desktop Node backend discovers its runtime or prepares files. Cancelled work cannot create a child later, and duplicate live run identities cannot replace another run's Stop owner.
    • Stop during native Node TypeScript preparation cannot launch cancelled code later. A late compiler result or rejection cannot steal cancellation from the next run.
    • Project tests preserve captured output order while running and after completion. Standard output and errors share one observed-order transcript, without duplicating messages or implying causal order between separate pipes.
    • Desktop startup failures now close safely with a concise English or Spanish recovery message. Missing renderer files and stalled loads cannot leave a blank app running; a refused second instance stops before registering handlers or opening a window.
    • Captured console output retains its observed order across standard output and errors. Independent stderr is no longer hidden by a later failure, and streamed runtime diagnostics are not repeated at completion.
    • Python exceptions are no longer mistaken for successful runs after output redirection. Tracebacks appear once, nested failures point to the innermost user line, and later runs recover normally.
    • JavaScript and TypeScript stacks prioritize user code and fold runtime details. Logged errors retain mapped stacks, including nested values; internal frames no longer offer broken editor links.
    • JavaScript and TypeScript diagnostics point back to the original source after instrumentation. Error and console locations compose timing, capture, loop and compiler maps; explicit arrow/watch captures retain their error classification.
    • Captured expression errors are visible in the console and diagnostics without stopping later captures. Failed runs no longer replace successful snapshots or appear as successful history. Console summaries distinguish completion, failure, Stop and timeout in English and Spanish.
    • Stop takes effect during runner preparation and keeps cancelled runs from changing later results. Late output, history records and finalizers are ignored; closing the running tab cancels its execution.
    • MCP text continuation preserves multibyte UTF-8 characters. Byte offsets no longer skip characters when a read ends inside a code point, and leading byte-order marks are preserved.
    • Packaged project tests use the installed Node.js runtime. Vitest and Jest run through their local project entrypoints without enabling Electron's disabled RunAsNode fuse. Missing Node and missing framework dependencies have separate recovery instructions.
  9. v1.5.0

    Security

    • The desktop app's local MCP server no longer ships a vulnerable request parser. hono moves to 4.13.7, clearing three advisories: toSSG() writing files outside its output directory, unbounded dot-notation nesting in parseBody() exhausting memory, and query parameters read after the URL fragment. The license service picks up the same fix.
    • The desktop app now runs on Electron 44. The upgrade brings the matching Chromium security fixes. The main process's bundled HTTP client moves to undici 8 and its WebSocket client to ws 8.21.3, both still covered by the bundled-dependency audit gate.

    Changed

    • The first TypeScript run is faster. The TypeScript toolchain now warms up while you type in a TypeScript tab, so the first run no longer waits for it. The first run measured about a third faster, and a real session gives the warm-up more time than the benchmark did.
    • Running a JavaScript notebook cell no longer downloads the TypeScript compiler. Notebook cells previously pulled about 0.9 MB of compiler on their first run, whatever their language; TypeScript cells now transpile with esbuild instead.
    • The editor loads Node.js typings only for the Node runtime, in one request. It used to fetch 126 typing files one after another (about 2.5 MB) as soon as you started typing, including on the web, where the Node runtime is unavailable.
    • Large runtimes start sooner on the web. The app opens its connection to the runtime download host ahead of time. Ruby now compiles while it downloads, and DuckDB verifies its payload's integrity off the main thread, with fewer copies of it in memory.
    • Programs that print a lot keep the console and results panel responsive. Streamed output now reaches the console and the results panel at most once per frame instead of once per line.
    • Project search caps results at 500 and says so. When a search hits the cap, a notice asks you to refine the query, and long result lists render only the rows in view.
    • Choosing Node, Deno or Bun in the web app reports right away that the runtime is desktop-only. It no longer downloads esbuild (about 14 MB) first.
    • Desktop Python starts without an extra read of its 10 MB runtime.
    • The natural-language SQL assistant adds a note only when a query needs explaining.

    Fixed

    • Editing a new Python tab while Python is still loading no longer loses results. The tab's automatic first run and the run triggered by the edit could both reach the runtime once it finished loading, and the inline results of the newer run could go missing.
    • Python is found the same way across the command line, the debugger and project tests. On Windows, debugging now works with only the py launcher installed; project tests also consider python3; and command-line runs pick up a virtual environment in a venv folder, not just .venv.
    • Background failures in the desktop app's main process no longer crash the app. This covers the Git HEAD watcher after its window closes and the rust-analyzer and gopls crash-recovery paths; the update check timer is also cleared on quit.
    • Long output with multibyte characters is cut at the real 64 KB limit. Text in scripts such as Chinese or emoji could previously pass three to four times the limit, and a cut could split a character.
    • Homebrew no longer warns about the Lingua cask on every update. The generated cask drops the deprecated verified: parameter.
    • Long sessions no longer accumulate memory for closed tabs in dependency telemetry bookkeeping.
  10. v1.4.1

    Fixed

    • The Windows desktop installer is back in the release payload. Version 1.4.0 published without a Windows build, so Windows installs and auto-updates stayed on 1.3.0. This release restores the NSIS installer and its update manifest with no other changes.
  11. v1.4.0

    Added

    • Agent verification now installs through native client workflows instead of manual file copying. Lingua ships one portable lingua-verify skill through the Agent Plugins 1.0 package and a native Claude Code marketplace, with managed install, update, reload, and uninstall commands plus bilingual setup guidance for VS Code, Codex, and Claude. The skill turns trusted local CLI runs, Capsule validation or replay, and utility transformations into structured evidence while adding no hook, credential, MCP server, or hidden execution authority.

    Changed

    • Paid checkout and license issuance now run through Lemon Squeezy. The pricing site uses the live Lemon Squeezy checkout destinations, while the existing Ed25519 license token contract remains unchanged for the app and CLI. The license Worker validates signed webhook bodies, pins the accepted store and variant identities, deduplicates deliveries with merchant IDs, stores merchant-neutral order and subscription references, and keeps unknown products and incomplete configuration fail-closed.

    Fixed

    • Packaged and custom-environment CLI runs now select host runtimes consistently. Standalone builds invoke the host Node.js executable instead of recursively launching themselves for JavaScript or TypeScript, while Python discovery follows Windows launcher and PATHEXT semantics, requires executable candidates on POSIX, and resolves PATH and PYTHON against the same filtered child environment used for execution. The standalone release packager now proves the JavaScript path with a real runtime smoke.
    • Refunded subscriptions can no longer regain a paid access window when later cancellation events arrive. Refund status is terminal across cancellation and renewal webhook paths, delayed deliveries cannot revive the license or mint a fresh token, and order refunds revoke both lifetime and subscription licenses through their stored merchant order identity.
  12. v1.3.0

    Added

    • The headless CLI now installs directly through Homebrew without asking users to run npm. brew install johnny4young/tap/lingua-cli consumes the checksum-pinned CLI tarball from the immutable GitHub Release, installs Homebrew's Node 24 runtime, exposes lingua on PATH, and places Bash, Zsh, and Fish completions in Homebrew's native directories; the existing npm channel remains available. Other channels can run lingua completion for a guided, fail-closed installer that detects supported shells, previews every target, asks once before writing, and keeps Zsh activation idempotent. The formula stays separate from the Desktop cask so either surface—or both—can be installed intentionally.

    Changed

    • Missing CLI runtimes now end with a recovery path instead of a bare PATH error. Python, Go, Rust/Cargo, Ruby, and Lua failures name the missing tool, show a platform-aware installation command, provide the matching version check, and link to the setup guide. JSON mode adds the same information as a structured recovery object so scripts can help users without parsing prose.
  13. v1.2.0

    Added

    • Scratchpad now keeps live values and failures beside JavaScript, TypeScript, and Python source. Top-level expressions render inline by default, thrown values use the error treatment without losing their full console detail, and one failed capture no longer prevents later expressions from reporting results. Python selects expressions with CPython's AST inside Pyodide so multiline syntax, indentation, declarations, control flow, function bodies, and docstrings retain their normal semantics; Settings and per-tab controls remain available when a quieter editor is preferred.
  14. v1.1.0

    Added

    • The Cron Parser now writes expressions from plain words. Describe a schedule the way you would say it — *cada 3 días a las 8am*, *weekdays at 9:30*, *every 15 minutes between 9 and 5* — and the utility generates the matching five-field expression, feeds it straight into the existing explanation and next-runs preview, and shows every default it filled in as a visible chip. It understands English and Spanish interchangeably, warns about the classic traps (day-of-month steps restart at month boundaries; date-plus-weekday is an either/or in cron), and refuses honestly when a phrase asks for something a single cron expression cannot express — a continuous every-two-weeks, or two times with different minutes — instead of shipping an approximation that fires when you did not ask. It also reads the vocabulary the established open-source parsers use — yearly and quarterly cadences, bare ordinals like *every 25th* or *the 1st and 15th of the month*, *every other day*, and *first Monday of the month* / *last Friday of the month* via the Quartz nth-weekday operators, each flagged as non-POSIX so you know to check your scheduler. It reads *cada quincena* / *quincenal* / *twice a month* as the 1st and the 15th — the payroll cadence that has no literal cron form but does have a conventional one — and says both that it made that reading and that the resulting gap is uneven. The same grammar is available outside the app as lingua utility cron-phrase, which reads a phrase on stdin and writes the bare expression, with --option annotate=true to append the assumptions and caveats as crontab comments. For free-form phrasing beyond the built-in grammar, an optional assist sends the phrase to the local AI endpoint configured in Settings → AI, validates the model's answer through the same parser before it can land, and suggests lightweight local models (around 0.4–1.3 GB) that handle the task well.
  15. v1.0.2

    Changed

    • Workspace icons now sit on one deliberate density scale. The chrome had drifted into six different icon-button sizes and five glyph sizes, with glyphs floating at roughly a third of their buttons — which is what read as unpolished. Icon-only controls now share two tokened steps (28px buttons with 16px glyphs, 24px with 14px for dense spots like tab close), the editor sidebar toggle no longer fights its own size override, and a build-time guard keeps future surfaces from inventing a seventh size.
    • The console's payload-kind chips became a single Types menu. The old row of six chips took nearly half the filter bar and looked identical to the severity chips beside it while behaving inversely (severity chips opt in, kind chips opt out). The menu lists every kind as a checked item, carries a count badge when something is hidden, and opens clear of the panel edges. The console header also drops a duplicated caption that wrapped to five lines at narrow widths.
    • Command palette results now rank actions first. Typing a verb surfaces the matching action ahead of snippets and templates that merely contain the word, with label matches boosted within each group.

    Fixed

    • The HTTP response empty state told users to click a button that does not exist. It said Send; the button is Run. Corrected in both languages — the Spanish copy also said Enviar while the button says Ejecutar.
    • Editor tab close buttons now show a keyboard focus ring. One of the two was also unreachable by keyboard entirely: it was hidden with a visibility rule that removes an element from tab order, so no ring could ever have shown. It now uses the same reveal-on-focus pattern as its sibling.

    Security

    • The YAML parser inside the desktop update path moves to its patched release. js-yaml below 4.3.1 carries a quadratic-CPU advisory in !!omap resolution (GHSA-5p4m-2wfm-xmqj) and reaches the packaged app through the auto-updater. The pin moves in the app graph and in the independently locked website project, which a root override alone cannot reach. No behavior changes.
  16. v1.0.1

    Security

    • The HTTP networking library inside the desktop app moves to its patched release: the desktop main process bundles undici to drive the SSRF-guarded HTTP proxy, so its version ships to users even though the package is declared as build tooling and the production dependency audit cannot see it. It now resolves to the advisory-fixed 7.29 line. The hono server library reached by the desktop local MCP server moves to its patched 4.12 release on the same pass, and the build-only fast-uri and postcss toolchains follow. The independently locked license and update Workers move to the same patched hono, undici, and postcss releases, so no deployed surface is left on an advisory line. No behavior changes; this is a dependency-only patch.
  17. v1.0.0

    Highlights

    • One workspace now spans experiment, inspection, and project work: write and run six languages, pause JavaScript/TypeScript or native Python/Go/Rust code, model multi-step ideas in reactive notebooks, and move into HTTP, SQL, or focused developer utilities without rebuilding context in another app.
    • Desktop project tools are explicit about trust: the integrated terminal, detected test runner, dependency actions, filesystem bridge, and local MCP server all start from an approved project capability, use bounded or filtered process boundaries, and explain where host permissions begin instead of pretending local code is sandboxed.
    • Web and desktop share the same local-first product model: browser-capable workflows stay inside workers and local storage, while host-only features are labeled desktop-only and cross narrow typed IPC bridges. Privacy-sensitive actions remain opt-in, telemetry stays off by default, and AI sends only a payload the user previews.
    • Repeatable work has first-class artifacts: Run Capsules and bounded multi-file Capsule Workspaces, named HTTP pipelines, notebook execution ledgers, project test evidence, CLI JSON output, and shell completion turn successful experiments into inspectable flows that can be replayed or automated.
    • The product is ready to explain as well as run: bilingual launch imagery now comes from deterministic current-build journeys, public copy labels Free, Pro, web, and desktop availability per workflow, and the CLI has one searchable task-based reference backed by the same typed catalog as terminal help.
    • The release path fails closed: immutable-release checks, signed desktop and standalone artifacts, checksums, notarization, Authenticode readiness, npm protected-environment promotion, public distribution audits, and candidate-safe website snapshots keep preparation separate from publication.

    Added

    • The headless CLI now has a human, searchable guide: the README starts with practical copy-and-run workflows, while dedicated English and Spanish website sections explain installation from source, files and stdin, project execution, utilities, Run Capsules, automation, shell completion, exit codes, missing toolchains, environment behavior, timeouts, and output limits. Responsive grouped navigation, accent-insensitive local search, and copy-ready examples keep the reference usable without sending queries anywhere; terminal help and the website command snapshot are generated from one typed catalog so flags, examples, and exit codes cannot silently drift.
    • Desktop Rust debugging completes the native debugger sequence: choose Debug on a Rust tab with an enabled gutter breakpoint to compile the current buffer with Rust 2021 debug symbols, launch it through host lldb-dap, inspect locals and a source-local call stack, refresh watches, and continue or step with the existing panel and shortcuts. Main discovers rustc plus lldb-dap (including Xcode through xcrun on macOS), uses filtered native environment data, bounds compiler/DAP/program output, keeps sessions renderer-owned, and removes the adapter, debuggee process tree, binary, and private source on every lifecycle. Normal Rust Run remains unchanged; web disables Rust Debug honestly, missing tools and compiler errors are actionable, and macOS debugserver denial surfaces Developer Tools guidance instead of a stuck session.
    • Desktop Go debugging now shares the full debugger workflow: choose Debug on a Go tab with an enabled gutter breakpoint to launch the current buffer through host Delve/DAP, pause with locals and a source-local call stack, refresh watches, and continue or step over, into, and out with the existing panel and shortcuts. The owner-bound typed bridge resolves Delve from the filtered native toolchain environment, frames bounded DAP traffic over a loopback-only ephemeral port, caps program output, and removes the process tree plus private temporary module on every lifecycle. Normal Go Run remains unchanged; web disables Go Debug honestly, native watches may have side effects, and missing Delve or macOS Developer Tools permission produces actionable guidance instead of a stuck session.
    • Desktop Python debugging now reaches the shared debugger UI: choose Debug on a Python tab with an enabled gutter breakpoint to run the current buffer through host CPython/pdb, pause with live locals and a source-local call stack, refresh watches, and continue or step over, into, and out with the existing panel and shortcuts. Main prefers a project .venv/venv, keeps sessions bound to their renderer owner, filters the native environment, bounds output, and removes the process tree plus temporary source on stop, replacement, failure, renderer destruction, or app quit. Normal Python Run remains Pyodide in both shells; web disables Python Debug honestly, standard pause breakpoints are the only Python mode, and the UI warns that native watches may have side effects.
    • Desktop projects can expose a secure, read-only local MCP endpoint on demand: Settings → Integrations requires explicit project-scoped consent, then starts a loopback-only session with an ephemeral bearer token and copy-ready client configuration. Four bounded tools provide project metadata, visible-file listing, UTF-8 reads, and literal search; main rechecks the root capability, blocks secret-like and binary paths, validates Host and Origin, and revokes the endpoint on stop, replacement, project close, renderer destruction, or app quit. Web remains honestly unavailable.
    • Desktop projects now have an honest integrated terminal: open it from the Explorer, Command Palette, or contextual bottom panel, review the real-shell trust boundary, then start the default system shell in the approved project root. The xterm surface keeps a bounded in-session transcript and supports interactive input, resize, clear, stop, and restart; main owns an absolute shell, filtered environment, renderer-bound session limits, and teardown on project revocation, window destruction, or app quit. The project root is explicitly a starting directory rather than a sandbox, and the web build omits the unavailable bridge and UI.
    • Notebooks now react across languages without running code behind your back: editing, reordering, changing the language of, deleting, or rerunning an executed cell marks the affected executed suffix stale across JavaScript, TypeScript, Python, and SQL while preserving its last output. Refresh stale explicitly rebuilds the notebook-owned JavaScript/Python kernels and replays only the recorded execution prefix in document order; never-run cells stay idle, replay stops on failure, and reloads retain a bounded execution ledger so silent setup cells are not lost. SQL remains honest about its shared DuckDB side effects rather than claiming rollback.
    • The HTTP workspace now handles live protocols and repeatable request flows: saved requests can use ordinary HTTP, server-sent events, or WebSocket sessions with bounded live previews, stop/timeout control, message and byte ceilings, and secret masking before both transient display and persistence. Named pipelines run up to 20 HTTP steps sequentially, refresh the active environment between steps so captures feed the next request, evaluate response assertions, and stop on network, HTTP, or assertion failure by default. Desktop requests now cross a typed lifecycle-owned IPC bridge into an SSRF-guarded proxy that checks and DNS-pins every HTTP/SSE redirect hop, disables WebSocket redirects, strips credentials across origins, and keeps private targets behind an explicit Settings opt-in; web stays within browser CORS, mixed-content, and private-network policy.
    • The JavaScript and TypeScript debugger now supports safe conditional breakpoints, logpoints, and watches: configure each active-file breakpoint inside the Debugger panel, distinguish its mode directly in the Monaco gutter, and keep bounded expressions refreshed at every pause. Conditions, watch expressions, and {expression} logpoint placeholders are parsed and interpreted over detached locals without eval, Function, calls, mutation, accessors, inherited access, or prototype traversal. False conditions continue, invalid conditions pause fail-safe with an explanation, and logpoints emit bounded output without stopping execution. Breakpoint modes and watch definitions persist; results remain session-only.
    • Run a project's real test suites from one local panel: the desktop Explorer and Command Palette now autodetect Vitest, Jest, Pytest, Go, and Cargo, show exactly why each runner matched, stream stdout and stderr, and support Stop. Every run stays behind the approved project-root capability and native-execution acknowledgement; main re-detects before fixed no-shell execution, filters inherited environment variables, caps output, permits one active suite per root, and owns the five-minute timeout. The web build keeps an explicit desktop-only state.
    • Capsule Workspaces add bounded multi-file handoff without a backend: from the Pro Run Capsules browser, choose related open text tabs, inspect the exact source, review possible secret findings, and copy or download one versioned JSON artifact. The additive wrapper preserves the stable Run Capsule and its CLI compatibility, forbids absolute paths and filesystem capabilities, caps supplemental content at 24 files / 2 MiB, and imports into a read-only Files viewer that opens one inert tab at a time without executing code.
    • Playground links now move into Lingua through a bounded preview: TypeScript Playground source decodes locally with an output ceiling enforced inside decompression, while Go Playground links fetch only the official fixed-origin plain-text endpoint with credentials omitted, redirects denied, a seven-second timeout, and a streamed 512 KiB cap. The source stays read-only until confirmation opens one code tab; URLs and source never enter telemetry, and providers without a stable public read contract fail with export guidance.
    • Bruno collections now import as a folder: choose a classic .bru, OpenCollection YAML, or mixed-format collection and preview its flattened HTTP requests before confirming. Folder import stays capability-scoped, excludes environments and hidden files, never executes scripts or assertions, and enforces file-count, byte, and request limits before writing workspace state.
    • The CLI now has a release-grade distribution pipeline: every selected release builds a minimal @linguacode/cli tarball plus native Windows and Linux x64 archives from Node's single-executable format, runs installed-package and standalone utility smokes, and folds every artifact into the public checksum manifest. Windows signs the embedded executable only after injection and fails closed when configured Authenticode credentials do not produce a valid signature.
    • Capsule compatibility now has a real stable-release journey: an immutable artifact from v0.15.0 is byte-pinned and carried through the current shared parser, renderer importer, CLI validation/replay path, and bilingual web import flow. The journey preserves source, stdin, argv, named input sets, and recorded output while retaining explicit update guidance for capsules written by a newer schema.
    • The CLI is now comfortable in an interactive shell: lingua completion bash|zsh|fish generates deterministic scripts from the shipped command and utility vocabulary, while --color=auto|always|never follows terminal capabilities and NO_COLOR without ever contaminating JSON or completion output. Every command now shares the same human error[reason] diagnostic shape, and malformed argv can return the established { ok, reason, detail } JSON contract instead of mixing plain stderr into automation.
    • The headless CLI now runs files, project roots, and Run Capsules: lingua run executes JavaScript, TypeScript, Python, Go, Rust, Ruby, and Lua sources through installed toolchains, resolves standard Node/Go/Cargo projects plus conventional entries, forwards stdin/argv, and owns bounded output, timeout, and process-tree cleanup. lingua capsule replay verifies the shared schema and source hash before execution, preserves recorded stdin/argv, and reports status/stdout/stderr drift in plain or stable JSON output without importing Electron or renderer code.

    Changed

    • Windows signing readiness is inspectable without exposing credentials: an authenticated read-only command now reports whether the repository has the complete WIN_CERT_FILE and WIN_CERT_PASSWORD name pair, blocks orphaned configuration, and emits Markdown, JSON, or bilingual standalone HTML without requesting secret values. A complete pair remains Review required until a real draft reports valid signatures for both the NSIS installer and standalone CLI and passes a clean Windows 11 behavior check, so configuration presence can never be mistaken for public trust.
    • Website release downloads survive GitHub API-only incidents without trusting stale data: the Astro build now falls back to a committed release snapshot only for transport, rate-limit, or GitHub server failures. The snapshot must match the repository and changelog version, contain a stable published tag, use canonical repository download URLs, keep asset names unique, and include the complete supported desktop matrix plus checksums; invalid API payloads and version drift still fail closed. Cloudflare Pages refreshes the snapshot before deploy when GitHub is healthy and verifies the committed copy offline when it is not.
    • CLI release prerequisites are machine-checkable before the irreversible window: one authenticated, read-only command now reports repository release immutability, the npm-production environment and reviewer count, bootstrap-secret presence, and the public npm package state in Markdown, JSON, or bilingual standalone HTML. It never requests secret values or mutates GitHub/npm, blocks a missing first-publish credential and a leftover post-bootstrap token, and keeps npm's stage-only trusted-publisher policy as an explicit human review instead of claiming evidence the available APIs cannot provide.
    • CLI registry promotion now has one guarded, auditable owner: a manual GitHub workflow accepts only an attested immutable stable release, verifies the npm tarball and checksum file against the signed release record plus their public digest, exact contents, version, repository, and operator confirmation, then exposes that evidence before the protected promotion job can be approved. The promotion job reverifies the transferred candidate before the unavoidable first publish uses one short-lived granular token with scope-limited write access, bootstrap-only 2FA bypass, and provenance; every later release is staged through short-lived OIDC for maintainer review and 2FA approval before a clean public-install smoke. Moving package invariants into a dependency-free contract keeps release verification independent of the desktop dependency graph.
    • Completed onboarding and package detection no longer compete with first paint: returning users keep only a persisted onboarding-stage predicate at startup, while the welcome source and run/snippet observers load only when a stage remains incomplete. Per-keystroke dependency classification now activates after the browser's first idle opportunity, preserves immediate privacy cleanup when disabled, and keeps Monaco's paste signal in a tiny shared leaf. The guarded web startup graph drops by three source modules and about 1.3 KiB gzip without changing first-run tips or package results. The activation harness also falls back to a single-process Chromium launch on locked-down macOS runners instead of failing before it can produce evidence.
    • Public product and pricing facts now match the shipping app: the bilingual website, comparison pages, getting-started guide, licensing page, and press kit now present all six runnable languages; the real three-tab, five-snippet Free tier; Team at $3 per seat per month; and paid notebooks, local AI, persistent history, and saved workflows without moving Free utilities behind a license.
    • Distribution readiness now reports public reality instead of relying on a stale checklist: one read-only command compares the latest stable release, expected desktop and CLI assets, npm publication, the public Homebrew tap, and generated winget manifests, with Markdown, JSON, and bilingual standalone-HTML evidence. The v0.15.0 Homebrew and winget manifests now match the published checksums; the report explicitly prevents retroactively publishing newer post-release CLI code as 0.15.0 and keeps npm, tap promotion, and Authenticode as visible operational gates. The release CLI packager also accepts pnpm's forwarded argument separator, so its existing package-only and signed-binary jobs execute as documented.
    • Shortcut reference copy now loads with Settings instead of every workspace: global dispatch, saved overrides, presets, and compact key hints keep a small structural catalog ready at startup, while localized labels, descriptions, groups, and search keywords arrive with the lazy Settings or shortcut-editor surfaces. The shared reference chunk is fetched once and reused across both surfaces. This removes about 1.5 KiB gzip from the initial web graph.
    • Run Capsule export now loads only after it becomes usable: fresh workspaces keep capture and the keyboard shortcut available without downloading the result-header control, sanitizer, clipboard writer, telemetry, or trust capture. The first captured capsule loads the button, while the shortcut loads the export pipeline only after confirming a capsule exists; failed chunks surface localized reload guidance. This removes about 2.2 KiB gzip and one chunk from the initial web graph.
    • Editor-tab actions now load only when requested: the tab strip keeps activation, rename, close, overflow, and keyboard detection ready at startup, while the portal action menu arrives after right-click or Shift+F10. Failed chunk delivery closes safely with localized recovery guidance, and the complete menu stays inside the viewport. This removes about 0.3 KiB gzip from the initial web graph.
    • Recent Runs now loads its history UI on first open: the result header keeps the per-tab count, Free upsell, and keyboard opener ready at startup, while rows, relative-time updates, pin/replay controls, and runner integration arrive after an eligible Pro user opens the popover. Localized loading and reload states make slow or failed chunk delivery explicit. This removes about 0.8 KiB gzip and one chunk from the initial web graph.
    • The floating Variables card now loads only when it can appear: normal workspace startup keeps the eligibility gate, while the draggable portal, value renderer, collapse behavior, and close action arrive after Variables is enabled with a matching scope snapshot. Localized loading and reload states keep slow or failed chunk delivery explicit. This removes about 0.5 KiB gzip from the initial web graph.
    • Recipe assertions no longer load with every workspace: Save-As keeps a small synchronous language-policy check, while assertion source composition and result parsing stay with the Recipes surfaces that use them. This removes about 1.9 KiB gzip from the initial web graph.
    • The project explorer now loads when its sidebar first opens: the app keeps drawer layout, focus management, and dismissal behavior ready at startup while recursive rows, context actions, open tabs, and list windowing arrive on demand. Localized loading and reload states make slow or failed chunk delivery explicit. This removes about 5.1 KiB gzip from the initial web graph.
    • The comparison renderer now loads only after Compare is enabled: normal editor startup keeps the snapshot gate and panel chip, while the diff UI, computed-diff hook, and worker client arrive with the first comparison. The panel shows localized loading feedback and a reload action if its chunk cannot load. This removes about 1.8 KiB gzip from the initial web graph.
    • Sharing now loads only when a link is sent or received: the workspace keeps the result-panel affordance, command listener, and tiny #share=v1 discriminator at startup. Outgoing encoding, confirmation, clipboard and telemetry load after a button, palette, or shortcut request; incoming decode and tab import load only for a matching URL fragment or accepted Smart Paste action. Both boundaries retry transient chunk failures with localized feedback. This removes about 2.1 KiB gzip from the initial web graph and another 1.9 KiB gzip from ordinary editor activation.
    • The main-editor AI explanation flow now loads after an explicit request: the workspace keeps only its shared request subscriber and localized loading/error shell at startup. The consent dialog, payload builder, structured answer renderer, and provider transport arrive when a Pro user asks to explain code; failed chunks close safely and can retry on the next action. This removes about 4.0 KiB gzip from the initial web graph.
    • The guided-tour engine now loads only when a tour starts: the workspace keeps a lightweight context and retryable loader at startup, while positioning, focus management, translated steps, selector polling, and tour controls move into an on-demand runtime. Failed chunk loads surface a localized retry notice instead of silently ignoring the request. This removes about 1.7 KiB gzip from the initial web graph.
    • The Electron-only desktop smoke harness now loads only when its bridge is present: normal workspaces keep a lightweight activation hook at startup, while the runtime matrix, failure expectations, artifact writers, memory snapshots, and execution loop move into an on-demand runner chunk. Smoke startup failures now report a failed result immediately instead of waiting for the parent timeout. This removes about 1.9 KiB gzip from the initial web graph.
    • The opt-in Run Ledger now stays out of normal workspace startup: the app keeps only its lightweight execution-history subscription and persisted preference check at boot. The ledger implementation and DuckDB client load on the first new manual run after the user enables the feature, or when an explicit Settings or SQL surface needs them; disabled runs remain non-retroactive and transient chunk failures can retry. This removes about 4.1 KiB gzip from the initial web graph.
    • Python and Ruby diagnostics now load with their language: the startup registry keeps only language metadata and asynchronous adapter loaders. Local analyzers download after a matching active tab reaches the diagnostics debounce, while failed loads remain retryable and fast language switches cannot write stale Monaco markers. The initial web graph drops by about 3.2 KiB gzip without delaying JavaScript startup.
    • Telemetry implementation now loads only for configured, consenting sessions: the workspace keeps a small privacy preflight and boot-duration vocabulary at startup. Builds without an endpoint and users who have not opted in no longer download the complete event catalog, redactor, license base-field resolver, or trust-ledger emitter; configured opt-in sessions load them on the first eligible event. This removes about 4.2 KiB gzip from the initial web graph while preserving endpoint validation, redaction, throttling, and best-effort delivery.
    • Developer Utilities now keep detection and transformations off workspace startup: the always-reachable catalog contains only search and entitlement metadata. Smart Paste loads a small predicate-only module with the editor, while the exhaustive Apply registry and full JSON, JWT, color, timestamp, and text analyzers arrive with an opened utility panel. The initial web graph drops by about 5.8 KiB gzip and one chunk without changing valid/invalid input behavior.
    • Git-aware startup now keeps the magic-comment engine on demand: the always-mounted Git status and HEAD-watch paths use a small directive policy instead of importing the full transformation engine. Magic-comment transforms still load with editor providers or execution, and the Playwright-only rich-console gallery now loads only on its gated validation route; together these boundaries remove about 20.7 KiB gzip from the initial web graph.
    • Dependency scanning no longer joins workspace startup: JS/TS and Python detectors load after the debounced active buffer may actually reference a package. The detection path no longer fetches Acorn just to confirm an empty dependency list, while the Dependencies panel and desktop/web classifications keep the same behavior once imports appear. Scratchpad execution may still load its shared parser independently.
    • Execution code now loads when work actually starts: manual Run and Debug, accepted Scratchpad auto-runs, and the desktop smoke harness keep runner orchestration outside the initial renderer graph. The lightweight controls remain available immediately, while validation, magic-comment instrumentation, and runtime adapters arrive with the first execution.
    • Project archive code now waits for an archive action: the web renderer no longer downloads the shared zip codec during normal workspace startup. It loads only when a user exports or imports a project bundle; desktop export remains owned by the trusted main process.
    • The closed bottom panel no longer taxes workspace startup: console, project terminal, debugger, preview, stdin, variables, dependencies, Git diff, and recipe UI now load when the panel first opens instead of joining every initial web and desktop renderer bundle. A localized loading state keeps the transition explicit on slow devices.
    • The app shell no longer runs an invisible second toolbar: AppChrome already provides the desktop drag region, so AppLayout now mounts only the floating execution control instead of also rendering a zero-height Toolbar with duplicate store and runner subscriptions. The standalone Toolbar remains available for its focused fallback smoke contract.
    • Run and workflow controls now agree about what can execute: the floating action pill and standalone toolbar share one capability policy for language, license, platform, notebook, and breakpoint gates. Debug stays unavailable until the active tab has an enabled breakpoint, unsupported Scratchpad choices explain why they cannot run, and disabled menu items expose the same localized guidance as the primary action.
    • Utilities, source navigation, and overlays now transition without effect-driven repair renders: Cron and hash results, Git diffs, document symbols, Project Search, What's New, Snippets, the Run menu, and tooltips derive their current state from the active request or user action, preventing stale output flashes and making loading and selection changes immediate.
    • Desktop Project Search now uses a packaged native search engine without depending on developer tooling: Lingua sends only capability-approved, visible text files to ripgrep in bounded chunks, cancels superseded searches, and transparently falls back to the existing JavaScript path if the executable is missing or fails. Existing file-size, file-count, binary, per-file, and total-result limits stay enforced.
    • The guided tour now teaches one complete feedback loop instead of opening a chain of tools: it moves from the editor to a real Run and then to the console, waits until desktop consent is resolved before starting automatically, and yields whenever the user opens another surface. Settings, Recipes, Snippets, search, and the command palette now also share one coordinated overlay slot, so shortcuts replace the current dialog instead of stacking modals.
    • Settings search now opens the preference you searched for: results include individual sections and high-value controls across every Settings tab, understand localized labels plus practical English and Spanish aliases, and move both the viewport and keyboard focus to the selected result instead of only dimming unrelated navigation rows.
    • Primary tasks are now discoverable by name in the Command Palette: Run active tab, Open project folder, and Apply license token join the existing runtime-switch and session-restore actions. Applying a license lands directly on the token field, while the floating runtime control now reports Browser preview, Deno, and Bun accurately instead of abbreviating or falling back to Worker.

    Fixed

    • The downloadable press kit contains the editorial kit it promises: the website prebuild now bundles the synchronized boilerplate, founder bio, launch drafts, pricing one-pager, and press README instead of producing a ZIP with only a placeholder file.
    • Pricing details are readable and structurally valid for assistive technology: cadence labels meet contrast requirements, and the expandable FAQ no longer uses invalid definition-list markup.
    • Curated project templates are now execution-tested before merge: CI materializes every scaffold in isolation, installs only its declared dependencies, and exercises the Express, FastAPI, Node CLI, React/Vite, and pandas paths with a diagnostic JSON artifact. The React starter now includes the compiler, Vite, type, and README files its declared build command needs instead of failing immediately on a missing tsconfig.json, and the Command Palette launcher now leaves the template chooser open instead of closing the newly selected overlay.
    • Project bundles no longer corrupt or silently omit files: web exports now read raw bytes instead of round-tripping assets through UTF-8, while web and desktop both abort when a file is unreadable or the shared archive limits are exceeded. Import now counts actual streaming inflate output as well as declared ZIP sizes, so dishonest headers cannot bypass the per-file or aggregate decompression budget.
    • Every Run control now reflects and stops the same active execution: the floating action, standalone toolbar, console replay, and keyboard shortcut share one manual-run lifecycle instead of each keeping disconnected local loading and stop state.
    • Production builds no longer inherit React's development runtime from the invoking shell: the canonical web and desktop bundle commands force their production environment before Vite transforms dependencies and reject generated renderer artifacts that still contain React development diagnostics.
  18. v0.15.0

    Changed

    • Run capsules now carry a real forward-compatibility contract: the parser distinguishes a capsule written by a newer Lingua (import tells you to update the app) from one whose format this build genuinely cannot read, and replays a registered migration chain for older capsules instead of rejecting them outright. The distinction has to ship before a second schema version exists, because an already-released build can never learn a new reject reason.
    • The browser build no longer downloads the code editor, the overlays, or the changelog before they are needed: the initial payload drops from 1.72 MB to 0.48 MB gzipped (1.77 MB raw, down from 6.76 MB). Monaco is fetched when an editor actually mounts, and Settings, the command palette, capsule browsing, the importers and the release notes each load the first time you open them. A visitor who lands on the start screen and never opens a file pays for none of it.

    Fixed

    • Go to Symbol lists real declarations in JavaScript and TypeScript files again: the Monaco integration now uses the worker API that ships in current production bundles, so functions, classes, and nested methods no longer collapse into an empty result in the web app.
    • Settings deep links open the section they promise again: the Pro upsell, license badge, and command-palette links used frame delays to navigate after opening Settings, which stopped being reliable when the modal moved behind a lazy boundary. They now hand the target tab to the next mount or navigate an already-open modal synchronously, without leaving a stale tab for the following open.
  19. v0.14.0

    Added

    • Windows joins the desktop release matrix: v0.14.0 produces a validated x64 NSIS installer alongside macOS arm64/x64 and Linux AppImage artifacts, with GitHub Releases as the canonical download and auto-update source. Authenticode is verified when signing is configured; otherwise the release records Windows as unsigned preview quality.

    Changed

    • License verification now supports overlap-safe Ed25519 key rotation: web, desktop, and the license service accept an ordered public-key ring while the service keeps explicit current/next signing slots, so keys can rotate without invalidating existing offline licenses.

    Fixed

    • Production browser licensing works from app.linguacode.dev: activation, trials, education, recovery, and device management now pass the Worker's closed CORS allowlist without allowing arbitrary origins.
    • Settings and SQL import controls keep their intended layout: the Settings dialog heading and native SQL file input are visually hidden again instead of consuming visible layout space.

    Security

    • Production dependency advisories are cleared for 0.14.0: the desktop updater now resolves the patched js-yaml line, legacy Electron tooling stays within advisory-fixed brace-expansion majors, the license Worker and marketing website use patched production dependencies, and CI/release audit every independently locked production graph instead of checking only the app root.
  20. v0.13.0

    Added

    • Explain selected code: Pro users can send an explicit editor selection to the configured bring-your-own AI endpoint from the editor or Command Palette, review the exact redacted payload before transmission, stream the explanation, and continue with follow-up questions.
    • HTTP response assertions: HTTP requests can define status, header, JSON-path, body-contains, and latency checks; results appear beside the response and are persisted with the request for repeatable API validation.
    • Actionable workspace empty states: HTTP and SQL now offer direct create/import actions instead of passive blank panels, reducing the path from opening a workspace to a first useful request or query.

    Changed

    • Developer Utilities are easier to navigate: the launcher groups the full utility catalog by purpose while preserving fuzzy search, favorites, keyboard navigation, and lazy panel loading.
    • The website reflects current product breadth: comparison pages, browser CTAs, trust evidence, release architecture labels, and the public roadmap now describe shipped behavior without exposing private planning metadata.
    • Monaco language support loads more selectively: basic-language tokenizers use a typed, exhaustive lazy-loader registry so a misspelled language identifier fails at compile time instead of silently degrading highlighting.

    Fixed

    • Immediate HTTP Send preserves assertions and captures: sending before the autosave debounce completes now builds and persists the request from all current editor state instead of dropping recently edited arrays.
    • HTTP and SQL panels remain usable at common laptop heights: their resizable workspaces use the intended three-column layout, preventing response controls from overlapping or intercepting clicks when the bottom console is open.
  21. v0.12.0

    Added

    • Magic comments are now discoverable in the editor: typing // @ (or # @ in Python) offers completions for the real magic-comment vocabulary — @watch, //=> arrows, @timeout, @time, and the presentation directives — each with localized hover documentation, so the inline-results language no longer lives only in the docs.
    • What's New stopped interrupting: after an update, instead of auto-opening the full release-notes overlay, Lingua shows a one-line upgrade notice once per version with a button to read the notes — and a persisted opt-out for people who never want the nudge.
    • Rotating hints on empty surfaces: the empty Console and the Command Palette now surface one of twenty curated tips per session. Hints are platform-aware (web never suggests desktop-only features), can be dismissed for good with one click, and can be re-enabled from Settings → General.
    • Live download progress while Python or Ruby boots: the first run on a fresh session used to sit on a static "Loading Python runtime (Pyodide)..." line while tens of megabytes downloaded. The run button now shows the live byte counter ("Loading Python runtime (Pyodide)... 34 MB / 60 MB") whether the boot started from a manual run or the scratchpad auto-run, and falls back to a loaded-only counter when the server sends no Content-Length. Failures keep their honest local error message.
    • Presenter mode (Cmd+Alt+P): one toggle for demos, pairing, and screen recordings — hides the sidebar, toolbar, action pill, and status bar while lifting the editor font by 4px and the console output by 2px. Toggling again (same shortcut, or the Toggle presenter mode palette action) restores your exact previous layout, because the mode never touches your saved preferences — even a reload mid-presentation leaves them intact.
    • Inline per-line timing for JavaScript and TypeScript: add a // @time comment (or enable Settings → Editor → Show per-line timing) and every top-level statement shows its wall-clock duration inline at the right edge of its line, with the slowest statement of the run highlighted red. Timings survive errors — statements that completed before a throw keep their measurements, and the failing statement reports how long it ran. Off by default; debug runs are never instrumented.
    • Cmd+; opens your recent commands: Lingua now keeps a per-session stack of the palette commands you execute. Press Cmd+; (Ctrl+; on Windows/Linux) to reopen the last eight — numbered 1-8 for one-keystroke re-runs, with relative timestamps — so repeating "that command I just ran" no longer needs the open-palette → retype → select roundtrip. The stack lives only in memory and clears on reload.
    • Smart paste now recognizes utility values: pasting a JWT, UUID, color (#hex / rgb() / hsl()), Unix timestamp, cron expression, Base64 text, or a JSON snippet into the editor offers a one-click Open in the matching utility action that opens the right Developer Utility with the value pre-loaded (a pasted Base64 value even lands in decode mode). Detection is deliberately conservative — existing share-link/capsule/cURL/stack-trace/JSON importers always win, code look-alikes like 5 * 60 * 1000 or hex hashes stay silent, and the same Smart paste toggle and Cmd+Shift+V bypass apply.
    • Share a run as a single HTML file: Run Capsules gain an Export as HTML action — in Settings → Account → Run capsules for the latest run and as a per-capsule row action in the capsule browser — that saves one self-contained .html document with the executed code (statically syntax-colored), stdin/arguments, stdout/stderr, status, duration, and environment metadata. The file opens in any browser with zero network requests (no scripts, and a default-src 'none' Content-Security-Policy backstop), declares the capsule schema version, and is localized to the app language. Desktop uses the native Save dialog; web downloads the file.
    • Positive offline status: the status bar now celebrates offline operation with a localized Offline — everything keeps working segment, disappears automatically when connectivity returns, and explains that local and cached runtimes remain available while updates, remote AI, and uncached runtime downloads pause. The desktop status bar now also honors the real Electron platform values and is enabled by default as intended.
    • Actionable native-toolchain recovery: when Go, Rust, desktop Node, or explicitly selected system Ruby is unavailable, Lingua now shows a localized warning with an installation guide and a live detection retry. Installing the toolchain during the session is picked up without restarting the app; Ruby automatic mode keeps its quiet WASM fallback.
    • Live Browser preview refresh: JavaScript and TypeScript tabs in Browser preview mode now refresh the sandboxed iframe 300 ms after typing stops, with Off and 1-second choices in Settings → Editor plus a first-line // @preview-refresh off|300|1000 override. Silent refreshes stay out of execution history, preserve the last successful DOM when new code fails, and show their effective interval in the preview footer.
    • TypeScript and Python Recipes: the practice library now includes three curated TypeScript recipes and three Python recipes, with language filters, matching .ts/.py tabs, localized prompts and hints, and real Run + Test execution through each web worker. Recipe assertions keep their results isolated from run history and the Result panel while coordinating with scratchpad auto-run so a test pass is not interrupted after editing.

    Fixed

    • Notebook edit-request CI stability: the animation-frame-deferred command-to-edit transition test now synchronizes with the frame itself instead of depending on a one-second polling window that could expire under the full Linux test load.
  22. v0.11.0

    Added

    • Run Ledger — query your own run history with SQL: an opt-in, local history of your manual runs, stored in the same DuckDB database the SQL workspace uses (schema lingua_ledger), so you can run code and then query your own history with the product's own SQL surface. Off by default; when enabled it stores only a SHA-256 content hash of the source (never the code itself) plus stdout previews taken from redacted-by-design run capsules and capped at 2 KiB. The ledger tables are deliberately visible in the schema browser — querying, editing, or dropping them is your right, and the ledger recreates itself on the next recorded run. Free keeps 7 days of runs; paid tiers keep everything. Clear drops the whole schema and Export downloads every table as JSON; both the toggle and Clear are logged to the Privacy trust feed. Durability follows the SQL workspace's OPFS persistence opt-in — without it the ledger is session-only, and the Settings card says so. Enable it in Settings → Account → Run Ledger.
    • SQL Column Explorer: a successful SELECT (or WITH … SELECT) in the SQL workspace gains a Profile columns action that opens a side panel with per-column type, null percentage, approximate cardinality, min, max, average, and standard deviation — computed locally through DuckDB's SUMMARIZE. Lazy by design: it only runs on an explicit click, never automatically, and never adds a run-history or ledger entry.
    • Named Input Sets (per-tab stdin + argv): save named combinations of the stdin buffer and command-line arguments on an editor tab and switch between them, so a tab can carry a "happy path" and an "empty input" fixture side by side. Input Sets round-trip through Run Capsules.

    Changed

    • Renderer telemetry has one typed React entry point: the shell, runner hook, dependency detection, smart paste, onboarding, console, dependency installer, and Developer Utilities now emit through a stable useTelemetry() tracker. Consent, redaction, and wire payloads are unchanged, while a compile guard and a decreasing legacy-call baseline prevent new stringly direct callers.
    • License-service compatibility now fails closed: every machine-readable license and trial response carries protocol version 1, and both the web and desktop clients validate that envelope before reading status or entitlement fields. Missing, malformed, or future versions clear the untrusted token and show a localized update notice instead of falling back to local verification.
    • The pay-once Pro tier is now a perpetual entitlement: the $59 one-time purchase unlocks the paid tier forever with 12 months of included updates, replacing the previous "every future update included" promise with a sustainable model. Your paid features never expire — a build published after your included-updates window shows a non-blocking optional-renewal notice, never a lockout. The offline Ed25519 verifier keeps a pay-once Pro token active regardless of its update-window date (revocation stays authoritative through the license server when the app can sync), and the product-id family check was tightened so a look-alike token signed with the same key is rejected. Public pricing, licensing, and purchase/recovery email copy are updated to match.
    • Free tier now opens three editor tabs: the Free editor budget rises from one tab to three, with the License upsell appearing when you open a fourth.
    • Utilities workspace is more readable and compact: epoch timestamps render as highlighted chips whose hover shows local time, UTC, and ISO 8601 (and the Timestamp panel gains a UTC output card); the JWT token is segment-colored (header / payload / signature) inside the real input, with a signature-status pill beside the label; pinned favorites open even when the active search filter would exclude them; visited panels stay mounted while the Utilities tab is open, so in-progress input survives navigating between tools (and is discarded when the tab closes); the workspace-local header folds into the shared editor chips row (copy-output hint + tool counter); and JSON outputs gain syntax coloring.
    • Faster, calmer startup: Lingua now paints a theme-matched editor skeleton while the renderer bundle loads instead of showing an empty window. On desktop, license verification runs in parallel after its IPC channels are registered, so opening the window no longer waits on disk/token initialization and the license surface shows a neutral verifying state until the real snapshot arrives.
    • Settings editor internals are easier to maintain: the SQL workspace defaults and persistence actions now live in their own focused settings component, reducing the parent editor-settings surface below the maintainability threshold without changing controls, copy, persistence, or DuckDB behavior.
    • Utility pipeline internals are easier to maintain: the persisted library/import controls and streaming results now live in focused components, reducing the pipeline orchestrator below the maintainability threshold without changing its controls, shortcuts, persistence, execution, or capsule behavior.
    • HTTP request editor internals are easier to maintain: request-builder tabs and their params, auth, headers, body, and capture panels now live in a focused component, reducing the request orchestrator below the maintainability threshold without changing auto-save, environment resolution, clipboard masking, sending, or cancellation behavior.
    • Settings navigation internals are easier to maintain: the rail UI and its filter metadata now live in focused modules, reducing the modal shell below the maintainability threshold without changing tabs, shortcuts, filtering, focus movement, or settings content.
    • Console internals are easier to maintain: ANSI parsing and collapsed-entry rendering now live in a focused row component, reducing the console orchestrator below the maintainability threshold without changing filtering, windowing, source-line pulses, rich output, or image-paste behavior.
    • SQL workspace internals are easier to maintain: the keyboard-operable data-import toolbar now lives in a focused component, reducing the workspace orchestrator below the maintainability threshold without changing file acceptance, busy states, input reset, schema refresh, or query behavior.
    • Scratchpad auto-run internals are easier to maintain: input decisions, execution orchestration, and result publication now live in focused modules, reducing the React hook below its maintainability threshold without changing debouncing, workflow gates, stale-run protection, inline results, console output, telemetry, or runtime timeouts.
    • Import overlay internals are easier to maintain: source detection, Postman variable re-previewing, and confirmed store writes now live in focused modules, reducing the React hook below its maintainability threshold without changing supported formats, lossy warnings, telemetry, notebook restoration, collection requests, or cancellation behavior.
    • Global shortcut internals are easier to maintain: catalog matching, action dispatch, debugger gates, and utility clipboard behavior now live in focused modules, reducing the React hook below its maintainability threshold without changing bindings, overrides, overlay handling, debugger controls, or utility feedback.
    • Project watcher internals are easier to maintain: event coalescing, external-reload prompts, and stale-tab detection now live in focused modules, reducing the React hook below its maintainability threshold without changing debounce timing, scoped tree refreshes, dirty-buffer confirmation, batching, or watcher cleanup.
    • Utility transform internals are easier to maintain: Base64 and URL now share one input/transform/output-registration cycle plus a common encode/decode toggle, with automated size and single-registration guards, without changing live conversion, Apply, history, copy shortcuts, or invalid-input behavior.

    Performance

    • Boot timings now cover the real startup boundary: the initial performance mark is emitted by the static document before the renderer module downloads or evaluates, so Copy boot timings includes bundle evaluation and import-time persistence work instead of starting after it. A capped-payload audit found no meaningful first-paint win from deferring notebook or utility-history hydration, so Lingua keeps immediate workspace access rather than adding a new loading interval.
    • Native execution probes no longer block the Electron main thread: Node and Ruby toolchain discovery, project/module lookup, dependency detection, and the guarded Windows npm-launcher search now use asynchronous filesystem APIs while preserving the same fallbacks and security checks.
  23. v0.10.0

    Added

    • Deno and Bun runtimes (desktop): the per-tab runtime picker (Worker / Node / Browser preview) gains Deno and Bun for JS/TS. Deno runs sandboxed with filesystem read scoped to the run's temp directory; both render as a disabled, actionable option when the binary is not detected on PATH.
    • Offline "Explain last error": a command-palette action that turns the most recent run error into a plain-language explanation plus concrete fix hints — entirely local, no network, no model, no code leaving the machine. A zero-config, private complement to the bring-your-own-key AI explainer; same Pro entitlement.
    • Benchmark a tab: a "Benchmark this tab" command runs the active file through a warmup plus repeated timed runs and reports timing statistics. Pro.
    • Install native dependencies (Go / Rust / Ruby): the dependency panel can install detected Go / Rust / Ruby packages on desktop via the toolchain (go get / cargo add / bundle add) — spawned with no shell and an argv array, specifiers validated against flag-injection and path-traversal, and only against an existing go.mod / Cargo.toml / Gemfile.

    Changed

    • Native runners share one spawn engine: the Node, Ruby and Rust runners now route their child-process execution through a single spawnNativeRun helper (no-shell spawn, POSIX process-group leadership, SIGTERM→SIGKILL escalation, whole-tree kill, output byte caps, and the opt-in stdin write with its EPIPE guard). Behavior-preserving internal refactor; the Go compiler stays on its own execFile timeout path. (Internal; no user-facing behavior change.)
    • Python debugger — desktop engine (groundwork): the desktop build gains a main-process Python debugger engine (src/main/pythonDebugger.ts) that drives a headless python -u -m pdb subprocess — set breakpoints, continue, step over/into/out, evaluate expressions, and structured { file, line, func } pause events (with the source line when pdb prints it), parsed from pdb's REPL. Python runs in Pyodide/WASM (no pdb), so debugging is desktop-only and needs host python3. The IPC bridge + renderer debugger UI (breakpoint gutter, step toolbar, variables panel) are a following slice; no user-facing behavior yet.
    • HTTP workspace — desktop SSRF-guarded proxy engine (groundwork): the desktop build gains a main-process HTTP engine (src/main/httpProxy.ts) that can bypass the browser CORS constraint while resolving every hop's host and refusing loopback / link-local / RFC 1918 / CGNAT / unique-local / multicast targets (an opt-in toggle relaxes this for private hosts), restricting schemes to http/https, re-guarding each redirect up to a hop cap, and dropping credential headers (Authorization / Cookie / Proxy-Authorization) when a redirect crosses origins — mirroring the browser it replaces so a public->public bounce cannot exfiltrate the user's token. It mirrors the existing response envelope byte-for-byte. The renderer transport seam + desktop Settings toggle that switch the workspace onto this engine are a following slice; no user-facing behavior change yet.
    • Interactive stdin + cloud-sync engines (groundwork): the Node/Ruby runners can keep stdin open for later writes (*:stdin-write / *:stdin-close) and stream live output over IPC, and a last-write-wins cloud-sync merge engine ships behind an injected transport. The REPL UI and a real sync transport are following slices; no user-facing behavior yet.

    Security

    • Supply-chain: the exotic git @electron/node-gyp subdependency is gone, and blockExoticSubdeps is back on. @electron/rebuild (via electron-forge) declared @electron/node-gyp as a codeload.github.com git-tarball dependency, which forced the pnpm exotic-subdependency guard off. The fork now publishes to the npm registry, so it is pinned to the registry release and the git tarball is removed from the lockfile — with the guard re-enabled, a future git/tarball subdependency now fails the install instead of being silently pulled.
  24. v0.9.0

    Added

    • Notebook — Python cells share a kernel: Python cells in a notebook now run against one persistent Python kernel, so a later cell sees the imports, DataFrames, and functions an earlier cell defined — the notebook workflow you'd expect from Jupyter, instead of every cell starting from scratch. Each notebook gets its own kernel: notebook A can't see notebook B's variables, and neither sees the editor scratchpad. "Restart kernel" (and closing the notebook) clears it. Cross-notebook/editor isolation also closes a latent leak where all Python runs previously shared one global namespace.
    • Notebook — SQL cells: a notebook code cell can now be set to SQL. It runs on the same DuckDB-WASM engine as the SQL workspace and renders its result set as a table (the same grid rich outputs use). Because the engine is shared, a table you CREATE in one SQL cell is visible to later SQL cells and to the SQL workspace, so you can build up a query across cells. DDL/DML statements show a short status line instead of a table, and query errors surface inline on the cell. SQL is a notebook-only cell language — it does not turn SQL into a general editor file type.
    • AI assistance — "Explain this error" (bring your own key): a paid, opt-in AI feature. Add your own OpenAI-compatible endpoint + API key + model in Settings → AI (stored locally only — never in exports, run capsules, share links, or telemetry). When something errors, an "Explain this error" action opens a dialog that shows you the exact payload first — nothing is sent until you choose Send — with obvious secrets redacted from the code excerpt. The trigger appears wherever an error surfaces: a notebook code cell, the editor console (using the active tab's source), a failed SQL query, and a failed HTTP request. The answer renders as formatted text — prose, lists, and copy-ready code blocks so a suggested fix is one click to grab — instead of raw Markdown. Lingua ships no default key or endpoint and makes no background calls. On the web build, requests are subject to your endpoint's CORS policy; desktop reaches local AI servers directly.
    • AI assistance — Apply & re-run: when the AI answer proposes code, one click applies it — behind a full diff preview showing exactly which lines change, because replacing your code is the one thing that should never happen blind. Confirming replaces the failing code and re-runs it immediately, closing the loop: error → explain → apply → green. Works on notebook cells, the editor console (active tab), and failed SQL queries; the HTTP surface has no code to patch and offers no apply.
    • SQL workspace — Ask AI (natural language → SQL): an "Ask AI" button in the query editor turns a plain-English request ("top 5 customers by total spent") into a DuckDB query. The only context sent is the live schema — table and column names + types, never rows or data values — and the consent preview shows that exact payload as you type. The generated SQL is inserted into the editor for you to review and run yourself; it never auto-runs.
    • AI assistance — streaming answers, follow-up questions, runtime-aware fixes, one-click Ollama setup: the explanation now streams in word by word instead of holding a spinner until the full answer lands — with a local model you see text in about a second, and a long answer that keeps flowing is never cut off (the timeout only fires when the stream stalls). After an answer you can ask follow-up questions in the same conversation; each send is still explicit, and the visible transcript is exactly what gets sent. The prompt now tells the model where your code actually ran — Pyodide, a sandboxed worker, desktop Node, DuckDB-WASM, the native Go/Rust toolchain — so it stops suggesting fixes your runtime can't execute (no more pip install advice inside a browser Python). And Settings → AI gains "Detect local AI (Ollama)": one click finds your local server, fills the endpoint, and lists your installed models to pick from. The desktop app's network policy now allows loopback (localhost) AI servers — the private, local-first path; remote endpoints on desktop still wait for the guarded proxy.
    • Notebook — tabular outputs render as a table: a code cell whose output is a homogeneous JSON array of objects (a terminal array expression, console.log([{…}]), or a Python print of a JSON list) now renders as a real table grid instead of raw JSON text, mirroring the console's auto-table. Same grid the console Details popover uses.
    • HTTP workspace — capture variables (request chaining): a new Capture tab on the request editor saves a value from a successful response — a JSON body path (data.token), a response header, or the status code — into a variable of the active environment, so the next request can reference it as {{VARIABLE}}. This turns the workspace into a real chaining client (log in → capture the token → call an authenticated endpoint). Captured variables whose name looks like a secret are marked secret by default, so they stay redacted in run capsules and exports.
    • HTTP workspace — Copy as code: the request's Copy button is now a "Copy as…" menu that generates a runnable snippet in cURL, JavaScript fetch, JavaScript axios, or Python requests, matching the exact wire request (composed headers + injected auth + default Content-Type). Environment secrets stay as {{placeholders}}, never resolved into the clipboard — same guarantee as Copy as cURL.
    • SQL workspace — column-aware schema browser + autocomplete: the schema browser now expands each table to list its columns with SQL types, and the query editor's autocomplete offers column names (typed detail, de-duplicated across tables) alongside table names and keywords. Introspection is a single information_schema.columns probe per refresh instead of one PRAGMA table_info per table.
    • SQL workspace — export results to a file: the result toolbar gains an "Export…" menu that downloads the current result as a CSV, JSON, or Markdown file. It writes exactly the rows on screen (the same filtered/sorted/capped view Copy uses) and, when the result is truncated to a preview, the confirmation says so — the natural path for a result too large to paste.
    • Accessibility overhaul: A sweep across the app brings full keyboard operability and screen-reader support — roving arrow-key navigation and ARIA semantics for the file tree, editor tab strip, command palette, quick-open, recipes, and capsule-comparison surfaces; focus management and traps for the guided tour, overlays, menus, and the execution-history popover; live-region announcements for console run summaries, project-search results, and other dynamic state; and a reduced-motion guard that quiets non-essential animation for people who prefer it.
    • Safer destructive actions: Irreversible operations — file and folder delete, pipeline delete, remove license, keymap and theme import overwrite, and replace-in-files — now route through a shared confirmation dialog, and recoverable deletes (snippets, capsules, clear console) offer an Undo toast that restores the item in place. The web file delete, previously unconfirmed, now always asks first.
    • Import data files as DuckDB tables: Load CSV, JSON, and Parquet files directly into the SQL workspace as queryable tables.

    Changed

    • Typed IPC contract: the entire preload↔main boundary now derives from a single source of truth (src/shared/ipcContract.ts). The preload bridge routes through typed helpers (typedInvoke / typedSend / typedOn) instead of hand-written as Promise<X> casts, and main handlers register through typedHandle, which binds each handler's return type to the contract. A renamed channel or drifted payload is now a compile error, and a drift test keeps the contract in lockstep with the registered handlers. (Internal refactor; no user-facing behavior change.)
    • Build-time env wiring is now gated in CI: the four-source env cascade for main-process defines lives in one shared helper (build/resolveEnv.mts), and a new drift test fails when a __LINGUA_*__ define is consumed by a surface whose Vite config never provides it, or when envDir drifts off the repo root — the class of regression behind the no-public-key production incident, previously only catchable with a manual packaged-build audit. (Internal; no user-facing behavior change.)
    • License IPC handlers join the typed contract: the renderer's ambient license tier type was widened to the full canonical six (free / pro / pro_lifetime / team / trial / education) so it matches the shared source of truth, which let the five license:* main handlers move onto typedHandle (return types now compile-checked against the contract) and closed the last documented exception in the typed-IPC boundary. Gating is unchanged — entitlements are free-vs-paid, so the two newly-typed tiers resolve to paid. (Internal; no user-facing behavior change.)
    • Desktop packaging and auto-update: Desktop builds now ship through electron-builder as native installers for every platform — macOS (signed and notarized .dmg / .zip), Windows (NSIS installer), and Linux (AppImage) — and auto-update through GitHub Releases. Linux desktop builds auto-update for the first time.
    • Large notebooks stay responsive: The notebook cell list is windowed, so a notebook with hundreds of cells mounts only the rows near the viewport while preserving scroll position and the row count screen readers announce.

    Security

    • License tokens are bound to the Lingua product. The verifier shape-checked productId but never bound it, so a token minted for a different product under the same signing key would satisfy validation and grant Lingua entitlements. Tokens must now carry a lingua-family productId; a foreign product id is rejected.
    • Web CSP: dropped the unused wss: from connect-src. Nothing in the web bundle opens a WebSocket, so an arbitrary-origin wss: allowance was pure attack surface with no consumer; it is removed. The broad https: stays and is now documented in the CSP as a deliberate product exception — the web HTTP workspace exists to fetch user-specified HTTPS endpoints, so its origins cannot be enumerated in an allowlist (plain http: remains blocked).
    • HTTP workspace: API keys under a custom header name no longer leak into shared capsules. An apiKey auth with a non-baseline header name (e.g. X-Custom-Auth) had its value written in clear into run capsules / share-links / CLI replay; the capsule serializer now redacts the auth-injected header unconditionally.
    • Git read-only layer no longer escapes the filesystem sandbox: the git:status / git:diff handlers now gate each requested file — not just the repo root — against the approved-scope containment check and the filesystem denylist, so a compromised renderer can no longer read unversioned files (.env, secrets in sibling packages) outside the approved subtree in the monorepo case.
    • License-server URL must be HTTPS: a misconfigured LINGUA_LICENSE_SERVER_URL can no longer send the signed license token over cleartext HTTP; only https: (and loopback for development) is accepted.
    • Native-runner env hardening: dynamic-loader injection keys (LD_PRELOAD, DYLD_INSERT_LIBRARIES, NODE_OPTIONS, …) are stripped from the user-supplied env tier as defense in depth; PATH stays allowed.

    Fixed

    • SQL workspace — the WASM engine survives a flaky CDN: the web build fetches the ~38 MiB DuckDB runtime from the R2 mirror (it exceeds Cloudflare Pages' 25 MiB per-file cap), and a transient 503/network blip on that single fetch used to fail the whole engine with "Could not load the SQL engine". The runtime fetch now retries transient 5xx/network errors with exponential backoff (a deterministic 4xx like a bot-mitigation 403 is not retried). The durable fix — edge-caching the immutable runtime prefix so R2 is barely touched — is documented in docs/runbooks/r2-release-mirror-setup.md.
    • HTTP workspace: editing the URL bar no longer deletes disabled ("commented out") query-param rows; you can now cancel an in-flight request (Send becomes Stop); and a stale settle can no longer clobber a newer request's execution state (per-request tracking).
    • SQL workspace: the table browser + autocomplete now populate on open and refresh after a schema change (with OPFS persistence, tables from a previous session were invisible until a manual Refresh); Copy CSV/JSON/Markdown now copies exactly the filtered/sorted rows shown in the grid instead of the full raw result; and a name collision on import is reported honestly instead of as a generic "parse error".
    • Notebook workspace: editing a markdown cell no longer serializes every notebook to storage on each keystroke (debounced like code cells), which also stops re-rendering sibling cells while you type.
    • Notebooks: re-running a JS/TS cell no longer throws Identifier 'x' has already been declared. Sandbox pull-ins now skip names the cell itself re-declares at top level.
    • File watcher no longer crashes the app: an asynchronous FSWatcher error (e.g. deleting the watched folder on Windows) is caught and surfaced as a degraded-watcher notice instead of taking down the main process.
    • File watchers no longer leak: a project watcher is disposed when its window is closed (macOS keeps the app alive) or the renderer reloads, instead of surviving to the next session.
    • Language servers: restarting rust-analyzer / gopls no longer spawns a duplicate orphaned server, and stopping one no longer emits an unhandled promise rejection.
    • Dependency install: cancelling or timing out npm install now terminates the whole process tree (node-gyp, postinstall) instead of leaving orphaned builds holding node_modules locks.
    • License (web): removing a license during an in-flight revalidation no longer silently resurrects it, including across browser tabs.
    • Editor: keystrokes typed while a save is in flight are no longer discarded; double-clicking a file in the tree no longer opens it twice.
    • Replace in files: "Replace all" freezes the confirmed query/replacement, so editing the inputs while the queue drains can no longer rewrite the remaining files with a half-typed search.
    • Native runners: a failed temp-file write no longer leaks the temp directory or escapes as a raw IPC rejection.
    • Window close: a crashed renderer no longer leaves the window (and the updater's install-on-quit) blocked forever.
    • Accessibility follow-ups from the audit: focus-visible rings on bespoke controls, guided-tour announcements scoped to step changes, pipeline list semantics with keyboard step reordering, recipe combobox and capsule-comparison tab roles, and clearer license invalid-state feedback.

    Performance

    • Lighter app-shell boot: Monaco (~3.8 MB / ~987 KB gzip) is no longer executed as part of the shell startup path — the LSP lifecycle hook and the Git diff panel now load it on demand, so it runs with the editor/diff surface that needs it instead of before the shell paints (and not at all on non-editor web surfaces).
    • Faster typing: the app shell no longer re-renders on every keystroke (the LSP, Git-status, auto-run, and dependency-detection hooks were subscribing to the whole tab list).
    • Faster native runs: Go and Rust toolchain detection is cached per session, saving one to two process spawns per run.
    • Editor tab strip no longer re-renders every row on each keystroke: each tab row is memoized, so typing in the active file re-renders only that tab's row (its Git status pill, glyph, and status dot) instead of the whole strip — the win grows with the number of open tabs.
  25. v0.8.0

    Added

    • HTTP + SQL workspace: A full-screen HTTP request workspace — reusable environments with secret-aware {{variable}} interpolation (URL, headers, and the auth tab), name-based header redaction in history and exports, cURL import, and each response captured as a run capsule — plus a DuckDB-WASM SQL workspace with a Monaco SQL editor (syntax highlighting, schema autocomplete, run-selection) and opt-in OPFS table persistence so tables survive a reload.
    • Notebooks grow up: Cell-based notebooks now run TypeScript and Python cells, share variables across cells for real, edit code in a Monaco editor (only the focused cell mounts an editor, so a 200-cell notebook stays responsive), and export/import losslessly to the native .linguanb document as well as Jupyter .ipynb.
    • Compare two run capsules: A side-by-side capsule diff shows Code, Input, and Output differences between two saved runs.
    • Importers — Postman: Import a Postman collection and have its collection-level and environment/globals {{variables}} resolve into runnable requests (with secret-named values redacted in the preview), instead of landing as literal placeholders.
    • Utility pipelines: Chain utility adapters into a saved, one-click workflow — the adapter vocabulary grew to 23, with a starter template gallery and the ability to save a pipeline run as a capsule. Single-shot utilities stay free; pipelines are Pro.
    • Persistent status bar: A bottom status bar surfaces language, lint error/warning counts, cursor position, indentation, the Git branch, and run status, with click-throughs to the next problem.
    • Privacy + Trust dashboard: Settings → Privacy now captures live trust events from the capsule-export, share-link, update-check, telemetry, and license surfaces, with per-feature "last network call" timestamps and a sensitivity-filtered activity feed.
    • Language scorecard per platform: A Web | Desktop filter resolves each language capability for the selected platform, with per-platform Markdown export.
    • Paste images into the console: Paste a screenshot into the console; an oversized image is downscaled to fit instead of being rejected.

    Changed

    • Design system: Closed the type, radius, shadow, and color scales across the UI for a more consistent surface.

    Fixed

    • Node.js is found across version managers: A packaged app launched from Finder/Dock inherits a minimal PATH, so a shell-managed Node (fnm, nvm, Volta, asdf, mise, nodenv, nodebrew) or a system install was invisible and every run reported "Node.js is not installed". Detection now probes the PATH first, then known version-manager and system install locations on macOS, Linux, and Windows. Snippets that use import or top-level await run as ES modules, and the editor resolves Node built-in types (crypto, fs, …) so they no longer show a spurious "cannot find module" error.
    • Console Details popover no longer clipped: The rich-output Details popover (table / object / array / chart / image / HTML) now portals to the document body, so it centers and scrolls instead of collapsing inside the console strip.
  26. v0.7.0

    Added

    • Smart paste: Pasting a Lingua share link, a run capsule, a cURL command, a stack trace, or a large JSON document into the editor now offers a one-click import through a non-blocking toast — open the share link or capsule, turn the cURL into a request in the HTTP workspace, or drop a large blob into a JSON tab — instead of landing as raw text. Cmd+Shift+V always pastes as plain text (also available as a "Paste as plain text" command), and a Settings → Editor toggle turns detection off entirely.
    • Inline lint and quick-fixes: JavaScript and TypeScript now surface problems as you type, toggleable per language in Settings → Editor. A built-in rule flags loose equality (== / !=) with a one-keystroke fix to the strict form, and quick-fixes can add a missing semicolon or wrap a selection in try/catch — alongside the editor's existing type diagnostics.
    • Reopen your last session: Lingua can bring back the tabs from your previous session on startup. Choose never, ask each time (the new default), or always from Settings → Editor; an "ask" prompt and a command-palette action let you restore on demand without auto-reopening private code after a screen share.

    Security

    • Notarized release gate: The macOS release workflow now fails closed when a build is signed but not notarized and stapled (xcrun stapler validate plus a Gatekeeper spctl assessment), and a release-time guard rejects any macOS update package whose filename the update feed cannot resolve — closing the gap that previously stranded macOS auto-update. The full update signature chain (manifest to installer to on-disk binary) is now documented in docs/RELEASE_SECURITY.md.
    • Git layer joins the filesystem sandbox: The read-only git integration now only operates on repositories that intersect the folders you have explicitly opened (including the repository root above a monorepo subfolder); arbitrary paths are refused, aligning git with the capability sandbox the rest of the filesystem already enforces.
    • Verified web runtimes: The standalone web build now verifies the sha256 of the Ruby and DuckDB WebAssembly runtimes fetched from the download mirror before instantiating them, and the web deployment ships hardening response headers (no sniffing, no framing, no referrer leakage).
    • Sandboxed HTML output locked down: Rich HTML console payloads now carry the same no-network Content-Security-Policy as the browser preview, both app shells gain base-uri/form-action CSP directives, and preview messages are validated against a closed per-type shape before rendering.

    Fixed

    • Rust compiles as edition 2021: Run and format-on-save now agree on the Rust edition — modern syntax (async, dyn, current into_iter() semantics) compiles instead of failing with edition-2015 errors.
    • Lua can no longer freeze the app: An infinite Lua loop now stops at the execution deadline with the standard timed-out message instead of permanently freezing the window, and unbounded print output is capped like every other language.
    • Stopping runs kills the whole process tree: Timing out or stopping a Node, Ruby, or Rust run now terminates any child processes the code spawned (with SIGKILL escalation), instead of leaving them running in the background.
    • Appearance theme buttons apply real presets: The Settings → Appearance theme buttons now switch the shell/editor to genuine presets instead of behaving as no-ops.

    Changed

    • Faster startup: The TypeScript transpiler (esbuild) now loads on the first TypeScript or Node-mode run instead of at boot, Go programs transfer their compiled WebAssembly to the worker without an intermediate copy, closed Rust tabs release their editor models, and the workspace session auto-save now re-arms only when the persisted snapshot actually changes instead of on every transient editor mutation.
  27. v0.6.0

    Added

    • Free developer utilities: Every single-shot developer utility (JSON, Base64, URL, UUID, hash, timestamp, JWT, color, diff, beautify/minify, regex, and the rest) is now available on the Free tier. The advanced utility *workflows* — multi-step pipelines, history that persists across reloads, and clipboard-on-focus automation — remain Pro, each with an in-app unlock prompt.
    • Deny-by-default desktop permissions: The desktop shell now refuses Electron permission requests (camera, microphone, geolocation, and the like) by default, granting only the narrow clipboard access the app actually uses.

    Changed

    • Faster startup and large-session performance: Monaco language providers and the developer-utility panels now load lazily, the console de-renders large output sessions (store-side collapse plus list windowing), and the project file-watcher refreshes only the directories that actually changed instead of re-walking the whole tree on every event.
    • Safer persisted data: The settings, license, and project stores are now schema-versioned with a migration registry, so upgrading across versions rehydrates saved state cleanly instead of dropping or corrupting it.

    Security

    • Branded filesystem capability ids: Root, watch, and relative-path tokens are now nominally distinct types, turning an accidental capability swap at the IPC boundary into a compile-time error rather than a runtime confusion.
    • Worker trust boundary: The JavaScript worker's AsyncFunction execution path is documented and regression-tested to confirm that Node-only globals (process, require) stay unreachable from user code.

    Fixed

    • macOS automatic updates: The update server now resolves the actual macOS release asset (the Lingua-darwin-<arch>-<version>.zip that electron-forge publishes), so packaged macOS builds receive updates again. Previously the server only matched a differently-ordered name, returned "no update," and silently stranded macOS users on the installed version. A regression test now locks the forge asset-name contract.
  28. v0.5.0

    Added

    • Signal-Slate redesign: A workspace-wide redesign pass that lands the new notebook surface, tightens the editor chrome, and folds in broad platform hardening across the renderer. The visual language carries forward from Signal-Slate v2 while the workspace layout, panels, and notebook entry points are rebuilt around it.
    • Notebook workspace: A literate, multi-cell notebook surface — ordered code and prose cells in one document — with one-step import of existing Jupyter .ipynb notebooks into native Lingua notebooks.
    • SQL and HTTP workspaces: A dedicated SQL workspace for ad-hoc querying and a full HTTP workspace for composing, sending, and inspecting requests, including import of Postman and Bruno collections.
    • Recipe practice library: A built-in library of runnable recipes for guided practice, with a run panel wired into the editor.
    • Run capsules: Portable, self-contained snapshots of a run (code plus inputs plus settings). Export a capsule, share it, and re-import it through paste, file picker, or drag-drop — all three load surfaces converge on a single shared parseRunCapsule validator. Includes a capsule browse overlay and an import-preview overlay.
    • Project bundle export and import: Pack an entire project into a portable .zip (isomorphic fflate, lingua-bundle.json manifest) and import it back through one zip-slip-guarded validation chokepoint with file-count, size, and zip-bomb caps. Export excludes node_modules/.git/dist/build; Mod+Alt+E, a FileTree button, and two command-palette actions drive it.
    • No-backend share links: Share a scratchpad as a self-contained link that gzips its payload into the URL fragment — no server round-trip, nothing leaves the device until you paste the link.
    • CLI companion: A lingua command-line companion for driving the toolchain outside the desktop shell.
    • Dependency management: A dependency detection panel plus install flows — JS packages and Python via Pyodide micropip on the web build.
    • Multi-file projects and cross-project replace: A multi-file project foundation with a find-and-replace workflow that spans every file in the project.
    • Utility pipelines: Chain developer utilities so the output of one tool feeds the next.
    • Ruby support: A hybrid Ruby runtime and language support, extending the multi-language matrix.
    • Rich media and rich console output: Inline chart rendering and a rich-media worker bridge for the console, Python rich-media parity, rich console payloads, and output source-mapping badges that trace each line back to its origin.
    • Onboarding choreography: A staged onboarding flow with status-notice priority so first-run guidance never collides with other notices.
    • Privacy and trust dashboard, language scorecard: A Settings dashboard surfacing privacy and trust posture, and a per-language support scorecard.
    • Git read-only layer: A read-only git surface with head refresh and reload notices, alongside a Settings cleanup that retired 11 Tier-S toggles.

    Changed

    • Console image paste: Paste images directly into the console.
    • Workflow canvas gating: The workflow canvas is now scoped to builder tabs on the web build.
    • Toolchain migration to pnpm: All three projects (desktop app, update-server, license-server) moved from npm to pnpm, with the operational docs swept to match. The worker projects bumped to TypeScript 6 and Vitest 4; inline charts now render on Vega 6 / Vega-Lite 6 / Vega-Embed 7.
    • Performance baselines: Web and desktop renderer footprint budgets rebaselined after the new features landed.

    Fixed

    • Update state across polling: Desktop now preserves downloaded-update state across the polling cycle instead of dropping it between checks.
    • Update-server caching: The GitHub API fetch cache is capped at 60 seconds and 204 responses are no longer cached, so update checks stop serving stale data.
    • Output source mapping: Tightened the gates that decide when an output line earns a source badge.
    • R2 release mirror: Pass --copy-props none so the mirror sync stops tripping over GetObjectTagging.

    Security

    • Patched tmp across the toolchain: Forced tmp 0.2.7 across the dev toolchain to clear the advisory.
    • Hardened GitHub Actions: Pinned every GitHub Actions step to a commit SHA and added least-privilege permissions and concurrency groups across the workflows.
  29. v0.4.0

    Added

    • Scratchpad excellence: A complete closeout for the JS / TS / Python Scratchpad workflow. Per-tab Run / Debug / Scratchpad mode toggle with the Run mode disabling auto-run for compiled languages. Smart auto-run completion gate so the runner waits for a coherent edit before firing. Pinned // @watch <expr> and # @watch <expr> annotations that survive across runs. Per-tab recent-runs replay with one-click rerun (Mod+Shift+H) and a Pro-gated <RecentRunsPill> in the result header (Free tier sees an upsell variant). Opt-in bare-expression auto-log mode for JS / TS with per-language Settings defaults and per-tab overrides. Pre-set stdin buffer with a dedicated bottom-panel Input tab consumed by prompt() / readline() (JS / TS) and input() (Python), with a "Used N of M lines" pill after the run. Per-language execution timeout presets (quick / normal / long / extended) with optional live mm:ss countdown pill and a // @timeout 60s magic-comment override. Compare-with-last-stable-run toggle in the result header with a multi-snapshot ring, pin/freeze support, three diff granularities (line / word / character), and inline + / − / ~ diff badges. Post-execute variable inspector panel mutually exclusive with Compare, surfacing typed previews for primitives, objects, arrays, Maps, Sets, errors, dates, and functions with Mod+Shift+I toggle, optional recursive expansion, and a case-insensitive name filter.
    • Explicit JS / TS runtime modes: Per-tab runtime selector with three implemented modes. Worker (default) keeps the existing fast Web-Worker scratchpad path. Browser Preview ships an iframe-sandboxed runtime with srcdoc CSP, runId-anchored postMessage bridge, parent-owned timeout, scoped multi-file preview seed, and an inspect-in-window button — useful for HTML / DOM / canvas demos. Desktop Node spawns a real node child process with a parent-owned SIGTERM→SIGKILL timeout, a NODE_TOOLCHAIN_KEYS env allowlist, automatic node_modules/ cwd resolution, package.json#type === 'module' detection, and a first-run trust notice before the first execution touches your filesystem and network.
    • Signal-Slate v2 chrome: New 36px header row above the toolbar with app mark, filename + unsaved dot, license badge, command-palette search, and settings gear. Toolbar trimmed of the seven right-side icons that duplicated the new header. Variables panel can now dock to a Variables tab in the bottom panel (Settings → Editor → Variable inspector surface) instead of the floating card. Toolbar chips (Lang / Runtime / Workflow) stay clickable even without an open tab and auto-create the right tab on demand so the toolbar can never deadlock the user out of a fresh session.
    • Rich-output foundation + //=> table directive: New RichOutputPayload type discriminator (superset of ScopeValue) covering map / set / date / promise / table / rawText payloads, with image and chart stubs reserved for a follow-up implementation. JS / TS runners attach a typed RichOutputTable payload when the user annotates an expression with //=> table — the inline pill upgrades from a JSON blob to a compact Table(N×M) — cols summary. Python's #=> table is recognised by the parser even though the Pyodide runner does not emit the payload yet. Foundation for the upcoming console-panel widget, popover surface, and chart / image / sandboxed-HTML rendering.
    • Debugger UX refinements: Breakpoint controls consolidated inside the debugger panel for a cleaner gutter, clearer affordances around the active debug session and the bottom-panel tab strip.
    • Public R2 release mirror: The release workflow now mirrors desktop installers, checksums, SBOM, and the third-party license report to a Cloudflare R2 bucket served at downloads.linguacode.dev. This is the public download surface for marketing-site CTAs while the source repository stays private. Includes a root manifest.json for programmatic discovery, a latest/ prefix that always points at the current release, a check:r2-mirror parity validator, and per-release evidence under output/r2-mirror-validation/<tag>.json. Setup runbook: docs/runbooks/r2-release-mirror-setup.md.
    • Telemetry export pipeline: New infrastructure path for periodic export of the closed-enum telemetry buffer to the update-server, enabling downstream analytics + observability without the renderer talking to a third-party service.

    Changed

    • Toolchain modernization: Vite 5 → 8 (Rolldown default), Vitest 3 → 4, ESLint 9 → 10, eslint-plugin-react-hooks 5 → 7, Electron 41 → 42, TypeScript 5 → 6, Pyodide 0.26 → 0.29, esbuild-wasm 0.27 → 0.28, Node engine moved to the 24.x family (any Node 24.X.Y release), not a fixed patch. Held @electron/fuses at 1.8.0 because @electron-forge/plugin-fuses 7.11.1 still pins ^1.0.0; documented in tests/build/depFreshness.test.ts. Three lint rules surfaced by the bumps (no-useless-assignment, preserve-caught-error, react-hooks/purity) re-promoted from warn to error after fixing every violation; four others (set-state-in-effect, immutability, exhaustive-deps, refs) intentionally stay at warn because the existing call sites are intentional useEffect patterns whose refactor would be a design change.
    • Toolbar layout: Toolbar no longer ships duplicated chrome (LicenseBadge, Open File, Quick Open, Palette, Snippets, Utilities, Console, Settings icons) — those moved to the Signal-Slate v2 header row. Left padding tightened to match.

    Fixed

    • Inline-pill overflow on long values: Stringified values longer than the editor's viewport used to paint past the right edge, wrap onto a second line, and overrun the gutter. Truncate at 80 characters with an ellipsis and surface the full text via the title attribute (visible on hover). The new //=> table directive side-steps this for array-of-objects entirely.
    • CompareResultsPanel purity: Relative-time strings inside the compare panel were derived from Date.now() inline in render, causing churn on every re-render. Anchored to the snapshot's capturedAt instead so the render stays pure (re-enables the react-hooks/purity rule at error).
  30. v0.3.0

    Added

    • Rich language intelligence for Python, Rust, and Go: Inline diagnostics, completions, hover documentation, and parameter hints. Rust uses rust-analyzer and Go uses gopls when installed locally; Python runs in-process. Web build keeps these languages in validate-only mode.
    • JS/TS debugger (preview): Click-to-toggle gutter breakpoints with Mod+Shift+B, a Debugger drawer with step controls, Settings entries to disable or clear all breakpoints, and TypeScript source-map composition so breakpoints stop at the line you authored.
    • Developer utilities productivity layer: Cmd/Ctrl+K launcher with fuzzy search, Cmd+Shift+C / Cmd+Alt+R to copy or replace utility output, per-tool history with persistence, drag-reorder favorites with full keyboard support, clipboard-on-focus consent, and Apply-from-input across 29 panels.
    • QR utility closeout: Drag-drop image decode, Copy-as-PNG, FG/BG color pickers with a WCAG-AA contrast guard, high-contrast preset, and SVG download.
    • Recovery experience: Safe-mode boot via ?safe-mode=1, automatic factory mode after repeated crashes, a Settings recovery section with five scoped resets, and a reveal-folder shortcut.
    • Profile backup and restore: Versioned profile export and restore with explicit conflict handling, replace confirmation, and machine-bound data exclusions.
    • Performance visibility: Release validation captures bundle size, runtime timings, and memory diagnostics before a build ships.
    • Release update feed gate: Desktop release validation now includes a draft-channel update-feed check with archived evidence.
    • Public-source readiness guidance: Release, security, auto-update, Cloudflare, performance, and source-available publication checks documented in one place.

    Changed

    • Desktop watcher reliability: Watcher diagnostics, opaque watch IDs, and degraded-event handling are documented and covered more directly.
    • Plugin hardening: Built-in plugin catalog and manifest validation reject malformed or prototype-derived ids more defensively.
    • Release validation: Performance budgets are part of the normal web-build quality gate.

    Fixed

    • Trust-boundary hardening: Filesystem capability checks and native runtime detection paths were tightened to keep host secrets out of subprocess environments.
    • Overlay accessibility: Modal overlays preserve dialog boundaries, contain focus, and restore focus after close.
    • Auto-update docs: Runbooks match the desktop updater's one-hour check interval.

    Security

    • Public-release secret scan: A gitleaks scan now runs as part of release readiness.
  31. v0.2.3

    Fixed

    • Web build stability: Lifted the Node heap limit for the web build job so release builds stop failing from memory pressure.
  32. v0.2.2

    Added

    • Public release hygiene: Added source-publication checklists, release security guidance, third-party notice reporting, and secret-scan configuration.
    • Offline Python runtime validation: Vendored Pyodide runtime assets with integrity checks so packaged desktop builds can prove Python runs without a CDN fallback.
    • Desktop release verification: Added production dependency audit, checksum verification, SBOM generation, and packaged macOS smoke coverage.

    Changed

    • Native execution trust boundary: Go and Rust execution now require explicit acknowledgement and use a filtered environment across detection and run paths.
    • Filesystem capability model: Desktop file access moved to root-token plus relative-path IPC contracts with protected-path enforcement.
    • Public web surfaces: Repo docs now point to linguacode.dev and app.linguacode.dev as the live public surfaces.
  33. v0.2.1

    Added

    • URL Parser (Developer Utilities): A new panel breaks any URL into scheme, origin, user, password, host, port, path, search, and fragment. Each component renders on its own card with a copy button, and the query string shows as a one-row-per-parameter table that preserves duplicate keys. The password cell stays masked until you explicitly reveal it.
    • String Case Converter (Developer Utilities): Type any phrase or identifier and see seven casings live: camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, Sentence case, and Title Case. The tokenizer understands acronyms (HTTPRequest → HTTP Request), letter-digit boundaries, and leaves CJK, emoji, and accented characters intact.
    • HTML Entity Encode / Decode (Developer Utilities): A new panel with four modes — Encode (minimal), Encode (named), Encode (numeric), and Decode. Named encoding covers Latin-1 Supplement plus common punctuation / symbol entities; codepoints outside the named table fall back to decimal numeric. Decode resolves named, decimal, and hex references and surfaces a small hint when any reference could not be resolved.
    • String Inspector (Developer Utilities): Paste any text to see its UTF-16 units, approximate graphemes, and UTF-8 byte length alongside a per-codepoint table that labels every character (printable, whitespace, control, invisible, BiDi). Warning cards call out zero-width characters, BiDi overrides, mixed-script words, and common Latin / Cyrillic homoglyphs — the usual suspects when a pasted string behaves mysteriously.
    • Diff Viewer granularity: The Diff Viewer now supports line-level, word-level, and character-level comparison via a selector at the top of the result. Word and character modes render inline so small edits pop visually, while the line summary keeps the familiar added / removed / unchanged counts.
    • More copy buttons across Developer Utilities: The UUID Generator, Timestamp Converter, JSON Formatter, and JWT Debugger now ship a dedicated copy affordance on every result — each generated UUID row, the four timestamp cards (Unix seconds, Unix milliseconds, ISO 8601, local time), the current JSON input, and the decoded JWT header and payload.
    • Backslash Escape / Unescape (Developer Utilities): Convert pasted strings for JavaScript, JSON, Python, or SQL-MySQL contexts, then unescape them back with clear inline errors when a sequence is incomplete or malformed.
    • Random String Generator (Developer Utilities): Generate one or many secure random strings with length, count, character-class toggles, and an option to exclude ambiguous characters such as 0, O, 1, and l.
    • Lorem Ipsum Generator (Developer Utilities): Generate placeholder copy as words, sentences, or paragraphs, with an optional classic opening and natural sentence rhythm for mockups, layout tests, and sample content.
    • Base64 Image Encode / Decode (Developer Utilities): Drop an image to create a data-URI, or paste a data-URI to preview it with MIME and size metadata. Oversized pasted payloads are rejected before preview so the app stays responsive.
    • JWT Debugger algorithm coverage: Verify and sign JWTs across the full HS, RS, ES, and PS families, including RS384 and RS512, without leaving the local renderer.
    • Beautify / Minify expansion (Developer Utilities): The panel now covers JSON, JavaScript, HTML, CSS, SCSS, LESS, and XML. JavaScript minify uses a real ECMAScript minifier, while markup and stylesheet modes preserve raw text, strings, URLs, CDATA, and other sensitive content.
    • SVG to CSS converter (Developer Utilities): Paste SVG markup and copy either a Base64 or URL-encoded data-URI plus a ready-to-use CSS background-image block, with detected size hints when the SVG exposes safe dimensions.
    • Cron Parser (Developer Utilities): Explain cron expressions in plain language and list the next scheduled run times from your machine clock, with English and Spanish descriptions plus a configurable upcoming-runs count.
    • Hash Generator closeout (Developer Utilities): Adds MD5 via a lazy-loaded spark-md5 chunk, SHA-384, SHA-512, HMAC over the full SHA family, plus a drag-drop file input so local payloads up to 50 MB can be hashed without ever leaving the device.
    • HTML to JSX converter (Developer Utilities): Paste HTML markup and copy valid JSX with React-compatible attribute names, self-closing void elements, inline styles translated to object literals, HTML comments converted to JSX comments, and multi-root inputs optionally wrapped in a fragment.
    • cURL to Code converter (Developer Utilities): Paste common cURL commands and generate equivalent code for fetch (browser), undici (Node), Python requests, or Go net/http. Headers, methods, inline bodies, basic auth, and cookies all carry over; file-backed bodies get a clear error, and unknown flags surface as inline warnings instead of hard failures.
    • YAML and JSON converter (Developer Utilities): Convert between YAML and JSON with a 2 / 4-space indent toggle. A diagnostic flags when YAML comments are dropped at the JSON boundary; quoted-scalar # characters are correctly preserved.
    • JSON and CSV converter (Developer Utilities): RFC 4180-compliant CSV ↔ JSON-array converter with configurable delimiter (comma, tab, semicolon, pipe), header-row toggle, sparse-row support, and full quoted-field handling for embedded delimiters and newlines.
    • Markdown Preview (Developer Utilities): Render Markdown to a sanitized HTML preview locally — DOMPurify backstops the sanitization and remote <img src="…"> attributes are stripped before rendering so nothing leaves the renderer.
    • SQL Formatter (Developer Utilities): Format SQL with ANSI standard, PostgreSQL, or MySQL dialect rules. Configurable indent (2 / 4 spaces) and keyword case (preserve / UPPERCASE / lowercase).
  34. v0.2.0

    Added

    • License management: A new License section in Settings lets you paste a Lingua token to unlock your plan. The current tier is visible next to the input, and a FREE / PRO pill in the toolbar shows your active plan at a glance. Click the pill to jump straight to the License section.
    • Environment variables: A new Settings section where you can define environment variables at the workspace or per-project level. Values stay on your machine and flow to desktop runners when you execute a file.
    • Expanded language catalog: Ruby, Java, Kotlin, Scala, Swift, C, and C++ files now open with proper syntax highlighting, file-extension detection, and a clear indicator in the file tree when they aren't runnable yet.
    • Privacy controls: A first-launch prompt asks whether you want to share anonymous usage signals before anything leaves your machine, and Settings → Privacy lets you change your mind at any time. Telemetry and crash reporting are off until you opt in, and never include your code or file paths.
    • About and What's New: Settings now ships a dedicated About panel with version and release links, plus a What's New overlay that surfaces these release notes without leaving the app.
    • Editable keyboard shortcuts: Rebind any built-in shortcut from the Keyboard Shortcuts overlay. Conflicts are detected and refused with a helpful notice, per-row and global reset restore the defaults, and your changes persist across sessions. Escape stays reserved so you can always close an overlay.
    • Keyboard shortcut presets: Switch between "Default (Lingua)", "Sublime Text-inspired", and "Classic IDE (JetBrains-style)" bundles in one click. Any manual edit afterwards flips the selector back to Default so the UI always reflects the truth.
    • Export and import your keymap: Save your personalised shortcuts to a JSON file or import one from another install. The file is validated for shape, version, and conflict-free combos before it is applied.
    • Theme packs: Settings → Appearance adds a theme pack selector. Pick "Solarized Daylight" for warm paper light mode, "Nord Night" for a calm blue-grey dark mode, or stay on the Lingua default. A pack swaps appearance, typography, and layout in one move.
    • Guided tour on-startup toggle: Every step of the guided tour now has a "Don't show this tour on startup" checkbox. A matching switch lives in Settings → About for anyone who wants to replay or silence the tour on demand.
    • Execution history everywhere: A new clock icon in the console toolbar opens a popover with your most recent runs — language, duration, and relative time — and the Command Palette surfaces the same list so you can re-run a recent file from the keyboard. Clear the history any time.
    • Number Base Converter (Developer Utilities): Convert integers between binary, octal, decimal, hexadecimal, or any custom base from 2 to 36. 0x, 0o, and 0b prefixes are honoured and underscores work as digit separators.
    • UUID v7 and ULID (Developer Utilities): Generate modern time-ordered identifiers alongside the classic UUID v4. A new decoder surfaces the embedded timestamp from any UUID v7 or ULID you paste.
    • Beautify / Minify panel (Developer Utilities): Pretty-print or compact JSON and JavaScript side-by-side. JSON round-trips through a parse and restringify; JavaScript gets an honest whitespace-only minifier with a clearly labelled hint.
    • Quick copy in Developer Utilities: Every result field in Developer Utilities — hex/RGB/HSL colors, hashes, Base64 output, URL encode/decode, Beautify / Minify results — now has a small copy icon that writes the value to the clipboard with a brief confirmation.
    • Format on save for Python: Python files now run through ruff (falling back to black) when format-on-save is enabled, alongside the existing support for JavaScript, TypeScript, JSON, CSS, Go, and Rust.
    • Support for infrastructure files: Dockerfile, Containerfile, Makefile, .gitignore, .dockerignore, .npmignore, .editorconfig, and shell scripts (.sh, .bash, .zsh, plus common shell dotfiles) now open with proper syntax highlighting.
    • Inline validators with friendly diagnostics: Running a JSON, YAML, .env, CSV, .editorconfig, Dockerfile, Makefile, .gitignore, or shell script file now surfaces lightweight warnings inline — duplicate .gitignore patterns, space-indented Makefile recipes, missing Dockerfile FROM or deprecated MAINTAINER, unknown EditorConfig keys, missing shebangs in shell scripts, and more.

    Changed

    • Dark / Light toggle: Picking a shell theme always takes effect now. Previously the "match shell to editor theme" option could quietly override your choice.
    • Clearer license errors: Invalid tokens surface a tier-specific explanation — "malformed token", "signature does not match", "expired", "clock is off", and so on — rather than a generic fallback.
    • Color Converter picker: The colour picker row now reads as a proper control, with a Palette icon and a hint line instead of an anonymous square.

    Fixed

    • Shortcut row spacing: Keyboard Shortcuts rows keep clear breathing room between the combo and the Edit / Reset buttons in every language, including Spanish.
  35. v0.1.0

    Added

    • Desktop code runner foundation: Electron Forge + Vite + React 19 shell with Monaco editor, project explorer, command palette, quick open, snippets, settings, and a structured console panel.
    • Language execution backends: JavaScript, TypeScript, Go, Python, and Rust execution paths, with browser support for JS/TS/Python and desktop-only native toolchain flows for Go/Rust.
    • Inline execution feedback: Result panel, per-line inline output, runtime markers, execution timing, and magic-comment support for dynamic languages.
    • Project and file workflows: Open folder, recent projects, loose-file editing, save/save-as, rename, delete, duplicate tab, and session restore support.
    • Monaco authoring support: Runtime-aligned JavaScript/TypeScript diagnostics, file-extension language detection, and immediate completion providers for Go, Python, Rust, and Lua.
    • Localization and docs: English/Spanish UI, i18n validation tooling, architecture docs, renderer reference docs, and contributor guidance for the renderer surface.
    • Packaging and update infrastructure: Desktop updater foundation, packaging metadata hardening, protocol registration, release checksums, and manual GitHub release workflows.

    Changed

    • Renderer architecture: Split oversized modules into focused feature folders for editor, file tree, command palette, settings, and project tree helpers.
    • Shell behavior: Responsive sidebar drawer, persistent resizable layouts, safer overlays over Electron drag regions, and cleaner settings/about organization.
    • Release and delivery model: CI now validates build quality; publish/deploy operations are explicitly manual.

    Fixed

    • Restored Go desktop execution after IPC regressions.
    • Hardened file-system IPC, rename handling, and trusted renderer navigation.
    • Fixed Monaco initialization crashes and synchronized diagnostics with execution output.
    • Corrected theme bootstrap to prevent shell flash on load.
    • Fixed Electron overlay interaction issues caused by draggable titlebar regions.

    Documentation

    • Added architecture guidance for project lifecycle, file-system IPC, and renderer ownership boundaries.
    • Added release, CI, and renderer maintenance documentation for future contributors.

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

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