English | 简体中文
Jasmine is an independent, open-source desktop GUI for the Pi coding agent, bringing Pi-compatible sessions, terminal workflows, skills, extensions, and agent interactions into a modern desktop app.
Jasmine is a community-built project and is not affiliated with or endorsed by Pi.
- Pi Sessions — keep Pi-compatible JSONL as the canonical conversation record, with persistent local threads, drafts, projects, search, and session import.
- Desktop GUI for Pi — use rich chat, attachments, Working tasks, memories, activity, and project context without leaving the desktop app.
- Pi Skills & Extensions — work with reusable skills, prompt templates, and Pi packages, including web access through
pi-web-access. - Integrated Terminal — run project terminals alongside coding-agent conversations.
- Fast file-change artifacts — inspect managed
write/edittargets with unified text diffs and before/after image snapshots, or opt into an event-based filesystem watcher for broader shell visibility without crawling the workspace. - Flexible models — connect multiple OpenAI-compatible providers with model discovery and per-model options.
Jasmine stores application data locally, but configured AI providers and any Pi packages you enable — including web access — can send data outside the computer. Review each integration before enabling it.
Pi-compatible JSONL is the canonical model conversation record. SQLite remains the transactional projection for thread lists, search, UI paging, settings, traces, and links back to JSONL entry IDs. See session storage and Pi session import.
Jasmine exposes each model request as a readable context taxonomy. The latest user task appears as soon as it is persisted and shows every provider subrequest (1/N) in wire order, with text, reasoning, tool calls/results, provider options, explicit unclassified fields, payload shape, actual usage, estimated composition, and DeepSeek/Kimi reasoning-retention validation. Sanitized raw payloads are gzip-backed and loaded only when expanded.
The example above uses two real model turns and opens the captured conversation context and provider request. See reasoning context retention for the provider-specific DeepSeek and Kimi rules that determine which historical thinking blocks must be replayed.
Jasmine consumes the standalone @jasmine-ai/pi-file-changes package through its host factory. The default managed-tools-only mode captures only exact approved write/edit targets and never walks the project, so unrelated large files cannot delay chat. The optional watcher mode observes native filesystem events for broader Bash visibility, but clearly reports that before content and causal attribution are not guaranteed. Neither mode parses shell commands or guesses renames.
The Artifacts panel stores each capture as a run-level observation ledger and lazily opens GitHub-style unified text diffs or bounded before/after image snapshots when those revisions are available. Editing or retrying conversation messages does not erase earlier captures because it also does not roll back the filesystem. Files selected by sensitive-path or high-confidence-content rules retain their path, status, hash, size, and mode, while preview bytes and diffs are redacted. Failed runs keep any evidence already captured.
Workspace, local context, and project tools
| Working | Search |
|---|---|
 |
 |
| Memory | Activity |
 |
 |
| Artifacts | Terminal |
 |
 |
Settings and integrations
| General | Providers |
|---|---|
 |
 |
| Appearance | Memory |
 |
 |
| Skills | Packages |
 |
 |
| Prompt Templates | Activity |
 |
 |
| About | |
 |
Download the appropriate asset from GitHub Releases and verify it against the published SHA256SUMS.txt.
- Windows x64: use
Jasmine-Setup-<version>-x64.exe. The installer is not code-signed, so Windows may show a SmartScreen warning. - Linux x64: use
Jasmine-<version>-linux-x86_64.AppImagefor a portable launch orJasmine-<version>-linux-amd64.debon Debian-based distributions. The AppImage may needchmod +xbefore its first launch. - Apple Silicon macOS: use
Jasmine-<version>-mac-arm64.dmg.
The macOS builds use ad-hoc signing and are not notarized. Trusted users may need to try opening Jasmine once, then choose System Settings → Privacy & Security → Open Anyway. Managed Macs may prohibit this override.
Settings → About checks GitHub Releases on every installed platform. What it can do from there depends on how the platform installs updates:
| Platform | Check | Download and install in place |
|---|---|---|
| Windows (NSIS installer) | yes | yes |
| Linux (AppImage, deb) | yes | yes |
| macOS | yes | no — opens the download page instead |
macOS is the exception because Squirrel.Mac validates a downloaded bundle against the running app's designated code-signing requirement. Jasmine's ad-hoc signature pins that requirement to one build's cdhash, so every later version is rejected with SQRLCodeSignatureErrorDomain. Signing the macOS build with a Developer ID identity is the only fix; the app detects a properly signed bundle at startup and switches itself to in-place installation with no further changes.
A Linux build launched outside its AppImage cannot replace itself either, and reports updates as unsupported rather than offering a button that cannot work.
- Node.js 22
- npm
git clone https://github.com/ArtificialNotImbecile/pi-desktop.git
cd pi-desktop
npm.cmd ci
npm.cmd run build
npm.cmd startDevelopment mode:
npm.cmd run devElectron stores Jasmine data in the operating system's application-data directory. Tests use isolated temporary user-data directories and do not reuse the normal profile.
Environment-variable references are the recommended credential method. For example, configure a provider with env:DEEPSEEK_API_KEY and set that variable in the operating system before launching Jasmine.
Jasmine also supports entering a key directly. Direct keys are stored as plain text in the local SQLite database. They are masked in renderer-visible settings, but they are not protected by the operating system credential vault. Do not use direct storage on an untrusted or shared computer.
Remote development over SSH now has a standalone CLI/package implementation in @jasmine-ai/pi-remote; desktop consumption remains gated on its live Windows-to-Linux acceptance matrix. Chrome browser control and MCP servers follow the same standalone-first rule. See the roadmap for the current boundaries.
Common checks:
npm.cmd run build
npm.cmd run test:unit
npm.cmd run harness:check
npm.cmd run test:e2e:smokeRun npm.cmd run test:e2e for the full Electron suite in background/off-screen mode. It keeps test windows transparent, non-focusable, and out of the taskbar; use npm.cmd run test:e2e:headed only for intentional foreground debugging. Run npm.cmd run harness:release for the complete local release gate; its final acceptance stage is intentionally headed. Generated screenshots, traces, audits, and acceptance results are written under ignored test-results/ paths.
Regenerate the README screenshots and real-model taxonomy GIF with npm.cmd run readme:capture. This command uses DEEPSEEK_API_KEY for three recorded model turns. Set JASMINE_README_EXECUTABLE and JASMINE_README_EXPECTED_VERSION to capture a specific installed release instead of the local development build; custom OpenAI-compatible DeepSeek gateways can also set JASMINE_README_DEEPSEEK_BASE_URL and JASMINE_README_DEEPSEEK_MODEL. Build the Windows installer with npm.cmd run dist:win and validate the unpacked application with npm.cmd run test:packaged. Linux and macOS packages are built and smoke-tested on their native GitHub Actions runners during a release.
See docs/harness.md for the test map and verification policy.
Start with the Jasmine documentation for Pi session behavior, storage, reasoning context, and desktop development workflows. Maintainers should read the development and release guide before publishing a version.
Read CONTRIBUTING.md before submitting a change. Report security issues through GitHub's private vulnerability reporting flow as described in SECURITY.md.
Jasmine is licensed under the MIT License.