Pearl Pearl
Download Sign in
Changelog

We ship.

Stable, Preview, and Next move on different cadences. This page is the ground truth — every published release, in reverse chronological order.

v3.7.25

stable 2026-05-29
  • # Pearl IDE 3.7.25 **Release date:** May 29, 2026 **Platform:** Windows (x64) --- ## Overview Pearl IDE 3.7.25 is the **Remote SSH** release. The Remote Explorer sidebar is rebuilt around the model VS Code users already expect — every configured host is expandable to its previously-opened folders, so jumping back into work on any of your machines takes one click instead of a connect followed by an Open Folder dialog. In the same release, Pearl's SSH stack gains the security guarantees a remote IDE has to ship with: host-key verification against `~/.ssh/known_hosts`, confirmation gates on every agent-driven remote command, loopback-only port forwarding, and integrity verification on the Node runtime that Pearl installs on each remote. ## Highlights ### Remote Explorer with per-host folder history
  • **Expandable host rows** — every host from `~/.ssh/config` (plus any
  • cloud-managed hosts on your Pearl account) shows a chevron. Open it to reveal the workspace folders you've previously opened on that host, most recent first.
  • **One-click reopen** — each folder row carries an "Open Folder in
  • Current Window" arrow and an "Open Folder in New Window" icon. Pearl connects to the host and brings the folder up directly, instead of dropping you on an empty Open Folder welcome screen.
  • **Active host highlight + inline disconnect** — the host you're
  • currently connected to is bolded and tinted, with a disconnect button that reloads the window back to your local environment.
  • **Open in New Window inline action** — every non-active host now
  • exposes a "Connect in New Window" icon next to the existing connect icon. The command was already wired; it's now actually clickable.
  • **Add Host wizard** — the `+` icon in the explorer header runs a
  • four-step Quick Input flow (alias → HostName → user → port) with inline validation, and appends a properly-formatted `Host` block to your config. The old behaviour of just opening the config file in an editor is gone.
  • **Fix: empty list inside remote workspaces** — when you were already
  • connected to a remote, the explorer used to come up blank. It now shows the same list it does locally, so hopping between machines is a real workflow.
  • **Status bar uses your alias** — the bottom-left "Pearl: …" label
  • shows the config-block name you gave the host (e.g. `prod-api`) instead of the resolved IP. The alias is what you mentally call the machine; that's what the IDE should call it too. ### SSH security hardening
  • **Host-key verification** — Pearl now consults `~/.ssh/known_hosts`
  • on every connection. Unknown hosts prompt with the SHA-256 fingerprint and a *Trust and Save* / *Trust Once* / *Cancel* choice; known hosts that present a different key are refused outright (same posture as `ssh` on the command line), and `@revoked` markers are honoured. Without this, every Pearl SSH connection was vulnerable to an in-path man-in-the-middle.
  • **Agent-mode SSH guardrails** — the `pearl_remote_connect` and
  • `pearl_remote_run` tools now require explicit user confirmation before each call, and ship with warnings against the optional "Always Allow" mode. Combined with the host-key check above, this closes the path where a prompt-injected README could send the agent to an attacker-controlled host or run an arbitrary command on a trusted one.
  • **Agent exec uses strict known_hosts** — the one-shot exec path used
  • by `pearl_remote_run` will not connect to a host that hasn't been trusted interactively first. There is no first-time-trust prompt in agent mode, by design: the user has to bring the host into known hosts via Pearl or `ssh` before the agent can talk to it.
  • **Port forwarding bound to loopback** — forwarded ports default to
  • `127.0.0.1` instead of binding to all interfaces, so the forwarded remote service is no longer reachable from anyone on the same LAN. An explicit address (e.g. `10.10.10.10:3000`) still opts you in. Duplicate forwards are now rejected instead of silently leaking the previous listener, and the disconnect handler properly tears down its subscription.
  • **Node bootstrap integrity check** — the Node runtime Pearl installs
  • on each remote is now verified against the official `SHASUMS256.txt` from `nodejs.org/dist/` before unpacking. Both fresh downloads and cached copies in `os.tmpdir()` are checked, so a poisoned cache or CDN compromise is caught instead of silently shipped to the remote.
  • **Passphrase prompts capped globally** — the per-key 3-attempt limit
  • is replaced with a 5-attempt global budget across all identity files, so a user with many keys is no longer prompted up to 3 × N times for the same password.
  • **Multi-key agent-mode auth** — `pearl_remote_run` iterates every
  • collected identity file via `authHandler` instead of binding to the first one, matching what the interactive provider already does.
  • **Default user follows the OS** — when no `user` is set in
  • ssh-config or cloud-host metadata, the SSH user defaults to your local OS username instead of `root`. ## Bug fixes
  • Folder-reopen from the Remote Explorer history now correctly opens
  • the chosen folder. Theia's workspace bootstrap reads the URL hash as a *path*, not a URI; we were passing the full `file://…` URI and ending up on the empty Open Folder welcome.
  • The Remote Explorer no longer hangs on "Loading hosts…" inside a
  • remote workspace. SSH-config path resolution now happens on the local-electron backend (always local) instead of via a renderer proxy that didn't return in remote sessions.
  • A regression that left the UI without theme or chrome (default
  • browser styling, menu bar missing) on first launch of a new build is fixed. An async `@postConstruct` on a service consumed by a `FrontendApplicationContribution` was poisoning Theia's eager startup container; the affected service now lazy-loads on first use. ## Installation & updates
  • **New install:** run `PearlSetup.exe` and follow the installer.
  • **Existing install:** Pearl updates automatically through its own
  • update channel; no manual action is required. ### On first run after upgrade
  • The first SSH connection to any host will prompt for host-key trust,
  • even if you've connected before. Pearl never populated `~/.ssh/known_hosts` previously — that's the intended catch-up behaviour. Subsequent connections to the same host are silent.
  • The Remote Explorer's per-host "Folders" history starts empty.
  • Workspace folders you open on a remote from this release onward are recorded automatically. --- *Thank you for using Pearl IDE. Feedback and issue reports are always welcome.*

v3.7.22

stable 2026-05-22
  • Release notes # Pearl IDE 3.7.22 **Release date:** May 22, 2026 **Platform:** Windows (x64) --- ## Overview Pearl IDE 3.7.22 introduces the **Planning Area** — a dedicated, persistent workspace for designing, executing, and tracking multi-phase work. Where Plan mode previously rendered a plan inline in the chat transcript, plans are now first-class objects: authored, edited, run phase by phase, and reviewed in a side panel of their own. This release delivers the Planning Area complete, from its foundation through its execution depth and intelligence layer. ## Highlights ### A dedicated Planning Area
  • **Plan library** — a searchable panel listing every plan, each card showing
  • status, phase progress, provenance, and last-updated time. Archive plans you are done with; delete the ones you no longer need.
  • **Plans persist** — every plan is saved to `.pearl/plans/` in the workspace,
  • so it survives reloads and is git-trackable.
  • **One renderer everywhere** — the chat transcript shows a compact plan chip
  • that deep-links into the Planning Area, where the full interactive plan lives.
  • **Extractable** — the Planning Area can be pulled out into its own window.
  • ### Authoring plans
  • **New plan, four ways** — describe a goal and let Pearl draft a phased plan,
  • draft one from a pasted spec or issue, start from a curated template (feature, bug fix, refactor, spike), or build one by hand.
  • **Full manual editing** — add, remove, and reorder phases; edit titles,
  • goals, steps, deliverables, and acceptance criteria in place. A plan can be authored end to end with no AI involvement at all.
  • **AI refine** — ask Pearl to revise a plan in plain language ("add a rollback
  • phase", "split phase 2"); the result merges in place and a banner shows exactly what changed. ### Trustworthy execution
  • **Verified phase completion** — a phase is marked done only when the agent
  • explicitly reports a verified outcome. A run that ends without one is flagged **Needs review** rather than silently claimed as complete.
  • **Checkable acceptance criteria** — criteria render as a checklist; the agent
  • ticks the ones it verifies, and you can correct them.
  • **Live per-phase activity** — while a phase runs, its card streams the
  • agent's tool calls as they happen.
  • **Per-phase change sets** — every phase's file edits are captured as a
  • reviewable set you can accept or **revert per phase**, leaving sibling phases untouched.
  • **Retry with feedback** — re-run a failed phase with an added instruction
  • instead of a blind retry.
  • **Auto-replan on failure** — when a phase blocks, Pearl can amend the
  • remaining phases around the blocker rather than simply stopping.
  • **Cost & time** — token usage and duration are tracked per phase and
  • aggregated for the whole plan. ### Intelligence & overview
  • **Plan ↔ chat linkage** — jump from a completed phase straight to the chat
  • turn that executed it; jump from a transcript chip back to its plan.
  • **Explain this phase** — ask Pearl, inline, why a phase is shaped the way it
  • is.
  • **Dependency graph** — declare inter-phase dependencies; execution respects
  • them, and a Dependencies view groups phases into levels that show which work is independent.
  • **Dry-run validation** — check a plan against the workspace before running it
  • and flag phases that reference files which no longer exist.
  • **Risk gating** — a plan rated high-risk requires an explicit confirmation
  • before an unattended "Run all".
  • **Revision history** — every refine and replan is retained as a numbered
  • entry so a plan's evolution is visible.
  • **Alternate views** — review a plan as a List, a Kanban **Board**, or a
  • **Timeline**, each with a plan-level progress bar. ## Stability & maintenance
  • The transient "Working…" todo dock is retired; the Planning Area's own phase
  • model is now the single progress surface.
  • Resolved a dependency-injection cycle that could destabilize startup, and
  • verified clean boots across the build. ## Installation & updates
  • **New install:** run `PearlSetup.exe` and follow the installer.
  • **Existing install:** Pearl updates automatically through its own update
  • channel; no manual action is required. --- *Thank you for using Pearl IDE. Feedback and issue reports are always welcome.*

v3.7.1

stable 2026-05-20
  • # Pearl IDE 3.7.1 **Release date:** May 20, 2026 **Platform:** Windows (x64) --- ## Overview Pearl IDE 3.7.1 centers on the AI chat experience: a redesigned conversation view, more reliable multi-conversation handling, and a refreshed Pearl gateway integration — delivered alongside a broad round of stability and cleanup work. ## Highlights ### Redesigned chat conversation view The chat panel has been rebuilt for clarity and parity with modern AI coding assistants:
  • **Clickable file references** — file paths mentioned in a response are now
  • interactive. Click one to open the file directly in the editor.
  • **File chips** — referenced files render as compact chips carrying the
  • correct file-type glyph from your active icon theme.
  • **Cleaner tool calls** — each tool invocation shows a status icon, a readable
  • past-tense action label (for example, "Read file" instead of `readFile`), and related steps fold into a single grouped card.
  • **Formatted reasoning** — the model's thinking is rendered as formatted
  • Markdown inside a collapsible block instead of raw preformatted text.
  • **Code-preview file reads** — file contents returned by the assistant display
  • as syntax-highlighted code previews rather than raw JSON envelopes.
  • **Friendlier errors** — tool failures and permission denials are presented as
  • clear, human-readable messages. ### More reliable multi-conversation handling
  • Every conversation is fully isolated end to end — its own message history and
  • its own gateway session — so switching between conversations never crosses messages between them.
  • **Context-usage indicator** shows how much of the model's context window the
  • current conversation is consuming.
  • **Conversation compaction** summarizes long conversations to reclaim context,
  • either on demand via the `/compact` command or automatically as a conversation grows. ### Refreshed Pearl gateway integration
  • Chat runs through Pearl's gateway using stateful cloud sessions, keeping
  • conversation history server-side.
  • Added support for mid-conversation amendments and server-side compaction.
  • ## Stability & maintenance
  • Resolved console errors observed in development builds.
  • Large internal cleanup: dead-code removal, consolidation of duplicated logic,
  • and fixes to a number of behavioral bugs.
  • Retired the legacy multi-provider chat architecture in favor of Pearl's
  • streamlined three-mode design — **Ask**, **Plan**, and **Agent**. ## Installation & updates
  • **New install:** run `PearlSetup.exe` and follow the installer.
  • **Existing install:** Pearl updates automatically through its own update
  • channel; no manual action is required. --- *Thank you for using Pearl IDE. Feedback and issue reports are always welcome.*

v3.0.0

stable 2026-05-16
  • # Pearl IDE 3.0.0 _Released 2026-05-16 — Windows installer: `PearlSetup.exe`_ Pearl 3.0.0 is a quality release focused on the AI chat surface: clickable file references, smoother inline-diff controls, accurate context usage, and a cleaner thinking-block experience. It also lands the server-side agent-loop fix that was leaking DSML tokens on DeepSeek resume turns. --- ## Highlights ### Clickable file references in chat File paths and `path:line` references inside inline `` `code` `` spans are now navigable. Clicking opens the file in the editor. Supported formats:
  • `` `app/controllers/AuthController.php` `` — relative path
  • `` `SiteController.php:12-15` `` — path with line range
  • `` `AuthController.php:42:5` `` — path with line:col
  • `` `src/foo/bar.ts` `` — nested relative path
  • `` `index.tsx` `` — bare filename with known source extension
  • Bare identifiers like `` `loginForm()` `` or `` `useState` `` are intentionally ignored — they have no path separator and no known extension, so a click does nothing rather than guessing wrong. ### Inline-diff Keep / Undo nav buttons The inline diff hunk navigator (the floating prev/next arrow bar) now includes compact **Keep** and **Undo** action buttons, separated from the arrows by a divider. They mirror the behavior of the conversation panel's "Keep All" / "Undo All" buttons — including the file-explorer yellow-dot cleanup that previously only fired from the conversation panel. ### Accurate context-usage chip The compact context-ring icon now correctly displays token usage and window utilization. Earlier versions passed the Theia session UUID straight to the gateway, which never matched a tracked session and returned no data. The chip now translates the Theia session ID to its backing cloud session ID via `PearlCloudSessionStore` before fetching usage. The cosmetic `?` glyph (`.pearl-context-ring__unknown`) has been removed from the icon. ### Thinking block: canonical text + cleaner labels
  • Reasoning streams are buffered IDE-side, then replaced by the
  • gateway's canonical thinking text via the new `thinking_complete` SSE event when each thinking block closes. The gateway-private `signature` field is never displayed.
  • The header label is now plain English (`"Thinking…"` / `"Thought
  • for Ns"`) — earlier builds emitted a "Could not find translation key" warning for every dynamic duration because `nls.localizeByDefault()` can't accept template literals. --- ## Bug fixes ### DSML tokens leaking on DeepSeek resume turns The server-side agent loop was only attaching `body.tools` to the **initial** turn, not to resume cycles. DeepSeek therefore had no structured tool channel on continuation iterations and embedded `<tool_call>` DSML tokens in plain assistant text instead. Fixed by extracting `toolsSpread` once above the cycle loop and spreading it into both the initial and resume `turnReq` objects, so every turn — initial or resume — carries the same tool definitions. ### "Keep" button (inline nav bar) didn't clear file-explorer markers Clicking **Keep** on the inline diff nav called only `sessionService.acceptAndClose()`, while the conversation panel's "Keep All" additionally calls `changeSet.removeElements()` — which is what actually clears the yellow ChangeSet dots in the file explorer and editor tabs. Fixed by adding `PearlEditSessionChangeSetCleaner`, a frontend contribution that listens to `sessionService.onDidChange` and removes all ChangeSet elements whenever the active session becomes `undefined`. This catches every close path — inline nav buttons, conversation buttons, programmatic close — without each one having to remember to clean up. ### `prompt_variables.tools` removed The gateway now auto-renders tool documentation from `body.tools`, making the IDE-rendered markdown duplicate redundant and a sync hazard (the two could drift if either side changed format). The IDE no longer sends it. --- ## Upgrading The 3.0.0 installer (`PearlSetup.exe`) upgrades cleanly over 2.9.x. No user-data migration is required. Workspace settings, sign-in state, AI session history, project memory (`.pearl/memory/project.md`), and the workspace index are all preserved. --- ## Build provenance
  • Built from clean workspace (yarn.lock pinned)
  • Forked Theia base: `@theia/*` 1.70.2
  • Electron app target, Windows x64
  • Signed: `Pearl.exe`, `OpenConsole.exe`, `rg.exe`, `elevate.exe`,
  • uninstaller, and `PearlSetup.exe`
  • NSIS installer artifact: `applications/electron/dist/PearlSetup.exe`
  • Unpacked artifact: `applications/electron/dist/win-unpacked/`

v2.9.0

stable 2026-05-14
  • Pearl 2.9.0 Release date: 2026-05-14 Channel: stable / windows-x64 Installer: PearlSetup.exe (381 MB, signed) Auto-update from: Pearl 2.0.0 Pearl 2.9 is the chat-conversational release. The model can now ask the user a structured question mid-conversation and the user can interject without breaking the agent loop — two patterns that together transform Pearl from "I'll come back when I'm done" into something that feels like working alongside the agent. Underneath, the tool-execution pipeline got significantly more resilient: parallel reads, per-tool timeouts, schema validation, transient gateway retries, and the removal of the 10-turn cap that kept agents from finishing genuinely complex tasks. This release is non-breaking. Existing chats, settings, persisted sessions, and keybindings carry forward from 2.0. Highlights Mid-flight amendments — type while the agent is working. When you have a follow-up thought during a long streaming response ("also handle the edge case where input is empty"), typing it no longer waits for the turn to finish or starts a new task. The note appears in a queued-amendments panel above the input, the gateway folds it into the next iteration with a "[the user added the following note while you were working]" preamble, and the agent integrates-and-continues instead of restarting. Cross-device: a note queued from your laptop appears in the IDE on your other device within ~25 s. pearlAskUser — model asks, you click. When Pearl needs a decision only you can make ("Should I create this file at src/utils/ or src/lib/?"), it now calls the new pearlAskUser tool and the chat shows a structured prompt: the question, 2–5 clickable suggestion buttons, an optional freeform input. The answer routes back to the model as the tool result and the conversation continues. No more ambiguity-driven guesses, no more "should I…?" questions stranded at the end of a turn. The 10-turn cap is gone. Pearl 2.0 halted agent loops at 10 turns with a "Reached 10 tool calls" warning. That cap was a blunt safety net — fine for runaway loops, frustrating for genuinely complex multi-file refactors. 2.9 replaces it with two smarter mechanisms: a consecutive-identical-call detector that soft-warns the model when it's stuck repeating itself (instead of halting the whole turn), and a 200-turn sanity backstop that exists purely to bound true runaway loops. Tools that don't hang. Every tool now runs under a per-class timeout (15 s for reads, 45 s for searches, 90 s for network, 180 s for terminal commands, 900 s for sub-agent delegations, with a 50% safety factor baked in). A hung handler returns a structured error to the model so the agent loop continues instead of stalling indefinitely. Parallel reads. When the model emits multiple read-class tool calls in one turn (readFile, listDirectory, textSearch, grep, fetch, …), 2.9 runs them as a single Promise.all batch. A three-file read drops from sum-of-three latency to max-of-three. Edits, terminal commands, and other stateful tools stay strictly serial. Reliability Tool execution survives gateway protocol drift. Some gateway versions closed the SSE stream after tool_call_end without an explicit turn_completed terminator, deadlocking the agent loop at turn 1 (the tool pill showed finished=true but the handler never fired). 2.9 detects this and runs the tools anyway, with a structured [pearl-gateway-anomaly] kind=missing-turn-completed … log line that climbs visibly if the backend regresses. Transient gateway errors retry pre-stream. A flaky 503, a 429 burst, or an SSE that closes before any chunk lands no longer kills a turn. Pearl retries up to 3 times with exponential backoff (500ms → 1500ms → 4500ms), honors server-supplied retryAfterMs hints when present. Retries happen strictly before the response starts streaming — once content has been yielded, errors propagate as before. Tool arguments are schema-validated before the handler runs. Catches the most common model-side errors (unparseable JSON when args were truncated mid-stream, missing required fields, non-object root) with a structured message the model can read and self-correct from, instead of letting a NPE bubble up from the handler. Long-poll wakes on sign-in. The cross-device sync channel used to back off up to 60 s when the user wasn't yet signed in — by the time auth landed, you'd wait the rest of the backoff. 2.9 wakes the poll the instant authentication completes. Silent edit failures now toast. When an AI-applied edit fails (file model dropped, streaming-apply throw, change-set bubbling failure), 2.0 logged to devtools and left the user thinking it worked. 2.9 surfaces these as throttled toasts — one per channel per 3 seconds — so a burst of related failures collapses to a single notification. System prompt no longer materialized when the gateway owns it. When delegating to the cloud gateway with agent_id=pearl-agent, the IDE skips assembling the 60 KB local system prompt entirely. Saves CPU + memory per turn and prevents prompt-duplication if the gateway ever stops dropping the leading system message. Bug fixes shipped during 2.9 testing Amendments URL used Theia session UUID instead of sess_<id> handle, causing 404s. The wrapper now resolves the cloud session id via the same lookup submitTurn uses successfully — symmetric handling across /turns and /amendments. Race in code-part-renderer: when chat re-rendered during streaming (amendments panel toggling, scroll virtualization), code blocks unmounted mid-creation and Monaco's createSimpleInline was called with a null host. Guarded with a mountedRef so the async create-then-attach sequence aborts cleanly when the component is torn down between awaits. Observability New structured log lines, all greppable in the IDE log channel: [Pearl-Tool] soft-warn: 3rd consecutive call to "<tool>" with identical args [Pearl-Tool] timeout: tool "<tool>" exceeded 45000ms execution budget [PearlArgValidation] <tool>: Tool "<tool>" is missing required argument(s): "path" [pearl-gateway-cloud] transient submit error (retry 1/3 in 500ms): <error> [pearl-gateway-anomaly] kind=missing-turn-completed cloudSession=… turn=… toolCalls=… detail="…" [pearl-delegation] agent=… parentSession=… promptLen=… outcome=… resultLen=… durMs=… [pearl-cloud-events] session.amendment_queued cloud=sess_… id=… [pearl-cloud-events] session.amendments_consumed cloud=sess_… id=… The pearl-gateway-anomaly line should stay at zero in healthy operation — climbing means a backend regression we can act on without anyone watching devtools. Under the hood pearl-gateway-language-model.ts split into a 1119-line orchestration file plus a 620-line pearl-gateway-wire-helpers.ts (message mapping, schema simplifier, tools[] budget enforcer, error formatter, cache annotation, prompt-variable rendering, parallel-safety classifier). MAX_TOOL_TURNS hoisted to named exports (RUN_TOOL_LOOP_MAX_TURNS = 200, RUN_CLOUD_SESSION_TURN_MAX_TURNS = 200) with rationale in JSDoc explaining why a sanity backstop exists at all. Cancellation guards added to inline-edit batches — applyEdits / recordInverseEdits / replaceInverseEdits accept an optional CancellationToken. A late chunk landing after cancellation can no longer leave the document in modified state with a partial delta. rejectAll position math now applies each inverse batch in its own pushEditOperations call in reverse order. Fixes a corner case where a batch that changed line counts caused subsequent batches' positions to validate against the wrong document state. Test type safety: 32 (store as any) casts in chat-session-store-impl.spec.ts replaced with a typed ChatSessionStoreTestApi interface; 14 orphaned eslint-disable @typescript-eslint/no-explicit-any comments removed. Localization keys in ai-chat-ui-contribution.ts migrated from theia/… to pearl/… (hygiene per CLAUDE.md "don't ship Theia branding"). What didn't change Forked Theia extensions (@theia/ai-chat, @theia/ai-chat-ui, @theia/ai-claude-code, @theia/ai-codex, @theia/ai-ide, @theia/ai-terminal) remain at upstream version 1.70.2. The exact-version match with upstream is what makes yarn-workspace resolution route every transitive @theia/* consumer through the Pearl fork. No changes to user settings, keybindings, persisted chat history, or the agent / mode contract. Existing 2.0 sessions persist into 2.9. Upgrading Auto-update users on the stable channel will be offered 2.9.0 on the next update check after the CDN serves the new artifacts. Direct download: https://ide.pearlfibers.com/ide/stable/windows-x64/PearlSetup.exe (upload pending — release artifacts are signed locally; CDN upload is the next step).

v1.71.1

stable 2026-05-14
  • What's in this release (since v1.71.0) Chat context dedup — attaching the same file twice is now a no-op Open-editors shortcut in the attach picker — currently open files are listed first for one-click attach Attach button moved next to Send (📎 ➤ order) — matches Slack / Cursor / Claude Suggestion row a11y — aria-live="polite" on the container; whole-body click is now ignored when the user is mid text-select

v1.71.0

stable 2026-05-13
  • Pearl IDE 1.71.0 Released May 13, 2026 · Windows · v1.71.0 The chat is faster, calmer, and harder to lose your place in. Highlights Cross-file change navigator. A new bottom-right pill summarizes the entire AI session — 5 files · +720 -105 · ▲ 13 / 47 ▼ — and lets you jump prev / next through every hunk across every file in two clicks. Walks straight into the next file when you're past the last hunk in the current one. Inline ⇄ chat sync. Accepting (or rejecting) the last hunk inline now auto-clears the explorer "edited" badge and removes the file from the chat changes dropdown. No more clicking Keep all just to dismiss the panel. Regenerate any answer. Every settled response gets a regenerate icon next to Copy. Same branch-history model used for editing your prompt — flip between answers with ▲ N / M ▼, keep what's best. AI editing got tighter The inline-diff subsystem learned new tricks and gave up bad habits: "Accept hunk 1, then reject all" no longer reverts hunk 1. Reverting an accepted change keeps Ctrl+Z coherent — undo still rolls the change back. Files over 2,000 lines now show only the touched hunks (Myers diff via jsdiff) instead of marking the whole file red + green. Per-hunk Accept / Reject lens widgets reconcile in place — cursor movement no longer flickers them. Chat UI, simplified The avatar / role header above each message is gone. Per-message actions (Copy, Regenerate, Edit) live in a single hover-revealed row at the bottom of each bubble. The pre-stream gap finally has a verb: Processing appears the instant you hit Send, transitioning naturally to Thinking → Writing → Reading / Editing / Searching / … as the model works. The duplicate error block under failed responses is hidden — errors read as a clean inline quote with no tinted chrome. The Edit pen + branch nav sit as a sibling row directly below the user bubble (not inside it), with tabular numerals so the 1 / 3 counter doesn't shift width as you cycle versions. Models PearlFibers Scout 4.7 and Peak 4.3 now appear in their own brand group at the top of the picker, with the server-provided display names, descriptions, and family-tier icons (frontier → rocket, fast → sparkle). The model picker consumes server-side providers[] metadata when available — display names, descriptions, family tags. Substring heuristics stay as fallback for orphan model ids. Auto-update, overhauled Unified feed URL: https://ide.pearlfibers.com/ide/{channel}/{platform}-{arch}/. One scheme for stable / preview / next across Windows · macOS · Linux, x64 · arm64. Telemetry: started, completed, failed, cancelled, user_declined — best-effort, never blocks the update flow. Declining or dismissing the prompt now reports back so adoption can actually be measured. Decline plumbing: clicking Not now, Never, or escaping the prompt all fire the same user_declined event, with the version being declined. Polish Help → About no longer lists every internal Theia extension. Blockquotes in chat lose their tinted-box chrome — they're prose again. The Loading models… sentinel in the picker resolves cleanly on first sign-in (no more "stuck on Loading" if entitlements fetch races a sign-in). The model picker re-renders the moment the server bumps entitlements_version — no restart needed when a model is added to your plan. Upgrade notes First launch may show "Windows protected your PC." Pearl 1.71.0 ships unsigned on Windows during this release window. Click More info → Run anyway to install; SmartScreen warnings will go away in the next signed release. Existing installs on 1.70.x will auto-update on their next check (within 60 min by default) provided your operator has mirrored the new release at the legacy …/ide/1.70.200/windows/ path. New installs auto-route through …/stable/windows-x64/. Pearl is built around modern AI workflows: chat, agents, and inline edits wired directly into your editor. pearlfibers.com

Stay in the loop

Pearl notifies you in-product when a new build is available on your channel. To pull updates manually, switch channels at /download or change auto-update behavior in Settings.

Want the why behind a release? The blog covers the bigger decisions; the changelog stays terse.