Skip to main content

Par Term Emu Core Rust

CI PyPI Crates.io PyPI - Python Version Runs on Linux | MacOS | Windows Arch x86-64 | ARM | AppleSilicon PyPI - Downloads Crates.io Downloads PyPI - License

A comprehensive terminal emulator library written in Rust with Python bindings for Python 3.12+. Provides VT100/VT220/VT320/VT420/VT520 compatibility with PTY support, matching iTerm2's feature set.

"Buy Me A Coffee"

Quick Install

Checksum-verified standalone binaries from the GitHub releases. Installs both the par-term-streamer streaming server and the par-mux multiplexer into ~/.cargo/bin (or $HOME\.cargo\bin).

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/paulrobello/par-term-emu-core-rust/main/install.sh | bash

Windows (PowerShell):

irm https://raw.githubusercontent.com/paulrobello/par-term-emu-core-rust/main/install.ps1 | iex

Options: --streamer / --streamer-mux / --mux (PowerShell: -Streamer / -StreamerMux / -Mux) install a subset, --version vX.Y.Z / -Version pins a release, and --bin-dir DIR / -BinDir picks a different destination. The default (no selectors) installs the plain streamer and par-mux; --mux combines with either streamer variant, --streamer and --streamer-mux are mutually exclusive.

What's New

Note: This section covers the releases from 0.63.0 through 0.82.0. The complete release history is in CHANGELOG.md.

Version 0.82.0 merges a 13-PR contributor series for the terminal core, with every reviewed fix applied: REP (CSI Ps b), SGR 21/58 and colon-truecolor forms, OSC 8 URIs keeping semicolons, the kitty keyboard pop default, 1049's SGR-pen restore through the DECSC/DECRC slot, intermediate-safe ESC parsing plus a spec-correct DECALN, xterm wrap semantics for wide characters in the last column, half-wide overwrite/erase partner blanking extended to the rectangle operations, and kitty animation frames that edit in place per the protocol (root-gap honored, bad c= an error, a=c rejected instead of corrupting the image). Opt-in additions: xterm.js-style reflow resize (Terminal::set_xterm_resize), live scrollback resize (Terminal::set_max_scrollback), per-code-point emoji widths (Terminal::set_codepoint_widths), and compact scrollback storage. The scrolling/printing paths are reworked for throughput (4-5x on the project's interleaved bench gate). Two behavior changes to note: a wrap flag now travels with its line through partial scrolls, and kitty a=f no longer creates an image from nothing (transmit first). Graphics stay honest: scrollback images follow their lines through eviction and shrink, kitty deletion follows the protocol's real deleting grammar (lowercase placements-only, uppercase frees stored data) with per-matrix error replies and spec negative-z frame gaps, and scrollback animation copies keep the frame they showed when they scrolled off. mux and streaming ride the same train: a paste payload can no longer end its own bracketed paste (a web page could plant a command through a copy handler), a resize the child never agreed to no longer reflows the grid (PTY ioctl/SIGWINCH runs first, failure returns before reflow), the streamer's CSP connect-src takes opt-in HTTPS origins for custom web roots, par-mux --keep-alive keeps a headless-started daemon waiting for its first window, broadcast client eviction is byte-budgeted (8 MiB per client, 16 MiB aggregate) instead of line-counted, and one plain output chunk no longer erases the damage queued in the same broadcaster batch. See CHANGELOG.md for the full notes.

Version 0.81.0 makes untrusted terminal output memory-bounded and the streaming protocol richer for remote pane management: a unified output memory budget (default 320 MiB, ENH-062) aggregates everything untrusted PTY output can make the terminal retain — decoded graphics pixels, the in-flight iTerm2 multipart buffer, and file-transfer payloads — reporting refusals through the new OutputBudgetExceeded event, and the kitty RGB and RGBA decode branches now enforce MAX_IMAGE_PIXELS before any payload copy. Streaming clients of mux-backed sessions receive the pane's working directory (Connected.cwd_hostname/cwd_is_local, CwdChanged.is_local) and can create named panes (PaneCreateRequest.name, validated ≤ 64 bytes; the handshake advertises pane_create_allowed). Agent rosters stay honest across kills: kill-window/kill-session cascades emit %agent-released (as does worktree-remove -f), presence stamps refresh on a 60 s cadence between full roster fetches, and an agent's report-state claim and reason stream through roster deltas. mux attach polish: the keybinds panel lists the copy-mode key table, and the click-latency harness now splits paint from delivery. See CHANGELOG.md for complete release notes.

Version 0.80.0 ships the select-layout multiplexer feature and hardens secret handling: par-mux select-layout [-t <target>] <preset> rearranges a window into one of five presets (even-horizontal, even-vertical, main-horizontal, main-vertical, tiled) through the full layout-mutation path (unzoom, PTY re-fit, %layout-change broadcast, persistence), and attach clients apply the same presets with prefix M-1..M-5 — rebindable through [client] layout-* chords in the settings dialog. The streamer gains --api-key-file / PAR_TERM_API_KEY_FILE (first line, trimmed, parse-time conflict with --api-key) so the API key stays out of ps output and shell history, plus startup refusals for unauthenticated/cleartext non-loopback binds without explicit --allow-unauthenticated / --allow-cleartext-auth. Security hardening closes an orphaned iTerm2 multipart memory-retention hole (restart fails the superseded transfer into the bounded ring; active_transfers caps at 8), percent-decodes query-param API keys before the constant-time compare, hardens DNS rebinding and auth backoff, and bounds frontend archive extraction. The mux tab strip keeps its configured width bounds across width changes (the long-standing tab-width reset bug). Downstream (Rust embedders): the crate is now a three-crate workspace — par_term_emu_core_rust::mux::… imports move to the standalone par-mux crate (root re-exports remain for this release), and cargo install par-term-emu-core-rust --bin par-mux is replaced by cargo install par-mux --features mux-bin,attach. See CHANGELOG.md for complete release notes.

Version 0.79.0 makes mux diagnostics and the daemon lifecycle cleaner: rejected and unparseable control-command log lines now name the peer on the other end (pid plus image path where the platform exposes peer pids, uid on macOS), a fresh default-instance daemon start hands off to the com.paulrobello.par-mux launchd job when it is loaded — no more adhoc-binary orphans losing TCC identity and LAN grants; PAR_MUX_NO_LAUNCHD=1 opts out — and the attach TUI's window picker lists windows only, a session no longer a selectable row, with a window name two sessions share disambiguated as session/name. See CHANGELOG.md for complete release notes.

Version 0.78.1 fixes the CI-only flake that blocked the 0.78.0 crates.io publish: the scrape fallback tests' fixture spawned a live shell, whose OSC title on the ubuntu runner outranked the idle_fallback rule the tests pin; they now use quiet sleep panes, so the fallback is the only reachable rule. See CHANGELOG.md for complete release notes.

Version 0.78.0 gives the attach TUI a full vi copy mode and makes agent rosters and restarts trustworthy: prefix [ now enters a complete copy mode on EVERY pane — the cursor roams scrollback plus a frozen snapshot of the screen at entry, v/V/Ctrl+V select character/line/block, y yanks per mode as an OSC 52 write and exits per the new [client] copy-mode-auto-exit setting, //? search with n/N, m{a-z}/'{a-z} mark and jump, and the scrollback editor moves to its own chord, prefix e; the session/window/workspace pickers open in search mode with live filtering and Enter-activates. Idle codex panes now enroll on the agent roster (the codex hook captures the full lifecycle, a fresh pane reports idle at SessionStart, and the scrape tick detects fresh agent panes from their process tree). Daemon restarts stop resurrecting dead agents twice over: hook v5 stamps each claim with the reporting agent's pid so a dead session can't ride a same-label replacement, and generated resume wrappers are no longer persisted as pane spawn commands. Streaming: pane output is never silently dropped on the relay to viewers (three drop sites closed, lagged clients get an in-band screen resync), the damage pairing survives quiet links, and pane BellRang events forward to pane-subscribed sessions. See CHANGELOG.md for complete release notes.

Version 0.77.0 makes the mux attach path faster and the streaming protocol richer for XR and web clients: host input reaches the render TUI at a few-millisecond floor instead of riding out the pump's 16 ms poll tick, a roster click's landing is one daemon round trip instead of two serialized waits, and cross-workspace roster clicks land focused on the clicked agent's pane; the refresh-client seed reply is ordered against %output (a buffering consumer's seed discard is exact) and a failed seed replay retries once and fails loudly instead of leaving stale panes. Streaming gains optional per-chunk damage ranges on output (repaint changed rows instead of scanning the whole grid), normalized raw-SGR mouse move buttons, opt-in pane creation via the mux bridge (--allow-pane-create), and an opt-in CSP connect-src blob: variant for custom web roots; par-mux gains prefer-default-workspace for target-less multi-workspace attaches and a window-add-replay verb that rebuilds a session's windows from the live tree. Web fix: the bundled terminal now reacts to the server's real mouse mode names and encodes the wheel as SGR 64/65 — mouse support was inert before. See CHANGELOG.md for complete release notes.

Version 0.75.0 brings env-gated OTLP metrics to the par-mux daemon and fixes how pane resizes move borders — a new opt-in otel cargo feature (default builds carry no OpenTelemetry code) lets a daemon export live sessions/panes/connected_clients gauges plus daemon_starts/client_connections/client_attaches counters to par-obs, gated again at runtime by --otel-enabled/PAR_MUX_OTEL_ENABLED with the streamer's endpoint/transport/headers flags (see docs/MUX.md); the agent-state Claude Code mod now ships with the claude hook integration, reporting question/working/idle live so the roster icon no longer sticks after a question is answered; and a daemon restart restores each agent's exec-time environment, so resumes survive a launchd-restarted daemon. Breaking: resize-pane -L/-U now follow tmux's border semantics — every direction grows the pane (the daemon previously shrank) — so old shrink-callers use the opposite flag, and the attach drag grammar was re-aimed to match. See CHANGELOG.md for complete release notes.

Version 0.74.0 makes par-mux's control surface harder to misuse and friendlier to discover: par-mux --cmd help now lists every control verb (including report-state) straight from the parser registry without a daemon, and unknown control commands point at it instead of failing silently; --cmd "" and whitespace-only commands exit with a usage error instead of hanging; the attach TUI enables bracketed paste (DECSET 2004) on the host for the session's lifetime, so multi-line pastes reach pane apps like claude code framed instead of submitting line-by-line (hosts without 2004 keep sending pastes raw); and new-workspace auto-disambiguates its first session's name tmux-style (main, main-2, …), so a bare new-workspace works even when a session main already exists, with --session-name naming the first session explicitly. See CHANGELOG.md for complete release notes.

Version 0.73.0 adds daemon-restart agent resume and roster presence in the streaming protocol — a daemon restart now resumes agents with a continuation prompt (the [daemon] agent-resume-prompt setting, default ON with assess-first wording), so a restored claude --resume <id> starts working immediately instead of idling at its prompt, and a persisted park message composes in front; and the streamer's roster frame carries the v0.72 activity/presence stats — last_activity_at/last_report_at/last_input_at/last_viewed_at, viewer_count, cpu_ms, stalled — so a streamer client sees everything the mux CLI roster shows, wire-compatible with pre-0.72 bytes. Fixes: the Par-mux launcher signs with an audio-input entitlement so its status-only microphone probe works under hardened runtime. See CHANGELOG.md for complete release notes.

Version 0.72.0 adds per-pane human-presence stats, agent self-reporting, and restore policies for par-mux — pane-info and list-agents now carry viewer_count/last_viewed_at/last_input_at/cpu_ms so a supervisor can tell a human is driving; agents can park a pane's roster state themselves with report-state; per-agent last_activity_at/last_report_at/stalled and a replayable events ring give supervisors durable lifecycle events; new-session --restore start-command plus set-workspace-restore-policy (start-command/agent-resume/none) let a supervised pane re-run its original launch flags across restarts and give a workspace a hard no-restore opt-out; and a nested claude -p can no longer hijack its ancestor pane's agent claim (hook v4 + daemon guards + claim recovery). Breaking: the streamer now refuses legacy {SHA}/$1$/$apr1$ htpasswd hashes at startup by default — regenerate with htpasswd -nB, or pass --allow-legacy-hash. Also: a view re-land deletes the previous view's kitty graphics from the host; PtySession exports and screenshots render from snapshots instead of holding the terminal lock; a multi-pane-tab roster click survives a lagging %layout-change; and TerminalClipboard ships as a Python-side feature-scoped facade. See CHANGELOG.md for complete release notes.

Version 0.71.1 fixes the mirror streamer dying on a client text frame: the tungstenite transport serving par-term-streamer --mux-socket treated any TEXT frame as a protocol error and tore down the session, so a probing client's control text frame (pardeck sends one on every connect) killed an otherwise healthy mirror; the path now logs and skips text frames, matching the axum /ws route. See CHANGELOG.md for complete release notes.

Version 0.69.0 makes the mux mirror a first-class pane citizen and the gate fit the host: a late joiner replays a pane's graphics even when they were placed before the streamer attached (refresh-client -G carries the placements in the seed, and the mirror tags every frame with its pane), every graphics frame on the wire — inline_image and graphics_added — carries its source pane for the coming multi-pane clients, the attach TUI's wheel scrolls menus, dialogs, and pickers with the arrows' scroll-into-view behavior while pane scrollback keeps the wheel, and each workspace gains an exit action (remove/hold/shell) set live via set-exit-action — shell respawns the user's shell when a pane child exits (crash-loop guarded, inherited by agent-append resumed panes). The gate itself now splits by load tolerance: 219 tests are labeled load-sensitive and leave the default gate (run exactly that set with make test-rust-sensitive; checkall-ci keeps full coverage), so a loaded host can still gate load-insensitive changes. The dependency train moved to current stable across Cargo, uv, bun, and CI action pins. See CHANGELOG.md for complete release notes.

Version 0.68.0 makes files and images flow both ways across the mux, and the TUI points at what it means: a phone (or any streaming client) can push a file into a pane with four new control verbs (upload-begin/-chunk/-commit/-abort) — staging is bounded (64 KiB chunks, 100 MiB per upload, 8 concurrent, idle/total timeouts) and commit bracket-pastes the materialized file's path into the pane rather than injecting bytes into its input. The connect handshake's inline-image replay is bounded for phone-cellular budgets (newest frames first, stopping at 8 MiB aggregate / 24 frames, skipped tail logged), replayed frames carry their exact cell positions, and a late joiner's Connected now includes the frames already on screen. In the attach TUI, drag-cursor-shape is renamed change-cursor-shape and defaults ON (an explicit false in an existing config still wins; the old key is ignored), the pointer takes the pointing hand over clickable tabs, and the tab context menu opens under the clicked tab instead of mid-screen, clamped on-screen for far-right tabs. The async attach cleanup completes: the seed's and re-seed's status snapshots ride the pump's send_then continuation (no snapshot round trip parks the view), a push handled mid-seed stays out of the transition baseline (identical rebroadcasts toast again), and a gone-window landing resolves from the cached roster first. See CHANGELOG.md for complete release notes.

Version 0.65.0 makes the streamer and par-mux self-updating and one-line installable: both binaries gain --check-update/--self-update plus an opt-in auto mode that checks at startup and on an hourly/daily/weekly cadence (default daily), driven by one checksum-verified release engine (crates/par-term-emu-core/src/self_update.rs), and curl -fsSL .../install.sh | bash (PowerShell irm | iex twin) installs them into ~/.cargo/bin with streamer/mux/streamer-mux selectors. The release matrix now publishes a mux-enabled par-term-streamer-mux-<os>-<arch> artifact beside the plain streamer — each build self-updates only from its own artifact — and macOS release binaries are Developer ID signed and notarized, so the application firewall's allow rule survives update swaps. Mux-backed streaming viewers get pane_size_status (effective grid plus separate column/row constraint owners) and viewer_presence pushes, and a phone viewer's Fit resize no longer sticks after it disconnects: mux mirrors close on last-viewer disconnect, withdrawing the streamer's size claim so the remaining viewers re-fit the pane. See CHANGELOG.md for complete release notes.

Version 0.64.0 makes par-mux's sidebar show workspace state at a glance: every workspace row carries a herdr-style git badge ( main ↑2, ahead/behind counts, hidden for non-repos, detached HEAD, or [client] git-status = false) resolved daemon-side from the pane's OSC 7-tracked cwd on a 2-second bound with a TTL cache keyed to the new [client] git-poll-secs setting (0 disables polling), and the marker column shows each workspace's most urgent agent status glyph — question is a first-class agent state end to end (scrape-tier dialog rules, sounds, notifications, prompt verbs), outranking blocked. A new [daemon] split-start-dir setting (home-dir | previous-pane-dir | workspace-dir) picks the folder a split-window pane starts in when no -c is given, and a new [daemon.agent-append] table carries per-agent resume words that agent-start appends when it launches one of the fourteen supported agents ({name} expands to the pane cwd's basename and every word is shell-quoted, so a configured value can never execute shell syntax). The streaming agent-roster entries gain workspace, project, and pane_label fields populated end to end (pane-title query, probe attribution), so ParDeck's phone roster can render them, and a restored daemon re-seeds its agents' last-known state so list-agents survives a restart. Seven fixes ride along: ED2/ED3 full-screen erases clear soft-wrap metadata so erased rows no longer stay joined in content() and par-mux capture-pane; kind-filtered event observers can subscribe to pointer_shape_changed again (the TerminalEventKind::ALL table had dropped it); the pane-stream seed's race check now samples its baseline before the export; bulk --install-agent-hooks covers all twelve hook arms (qwen, qodercli, devin, kimi, and mastracode were missing); the workspace status glyph sits next to the workspace name instead of displacing the marker column; a streaming session close no longer panics when the drain thread runs off the Tokio runtime; and reload-config re-reads the applied copy's stamped config path. See CHANGELOG.md for complete release notes.

Version 0.63.0 makes par-mux self-updating and extensible: par-mux update [--channel stable|preview] downloads the platform archive from GitHub releases, verifies the new binary's --version before replacing anything, keeps par-mux.previous beside it, and restarts the daemon through the stop-and-restore handoff; a checksum-verified curl|sh installer and a Homebrew tap template join it. The release also ships a trust-gated plugin system (manifests, event hooks), saved machines and an SSH thin client, persistence resilience (snapshot history, logind shutdown inhibitor), a macOS app-bundle wrapper for TCC permissions with launchd autostart, and a large attach batch — an interactive session picker, kitty graphics rendered in panes, popup command windows, theme presets with auto light/dark switching, IME/CJK input, drag-to-highlight copy, and jump-to-notification. Daemon side: git worktree workspaces, the done agent state, agent-start/agent-prompt/agent-explain/wait-output/show-notification control commands, raw pane streams for local clients, shell completions, and herdr's agent-integration ports. Breaking for configs that set notify-states explicitly: [client] notify-states now defaults to ["blocked", "done"], so add "done" to keep hearing about background finishes. See CHANGELOG.md for complete release notes.

Every other release is documented in CHANGELOG.md.

Features

Core Terminal Emulation

  • VT100/VT220/VT320/VT420/VT520 Support - Comprehensive terminal emulation matching iTerm2
  • Rich Color Support - 16 ANSI colors, 256-color palette, 24-bit RGB (true color)
  • Text Attributes - Bold, italic, underline (5 styles), strikethrough, blink, reverse, dim, hidden
  • Advanced Cursor Control - Full VT cursor movement and positioning
  • Line/Character Editing - VT220 insert/delete operations
  • Rectangle Operations - VT420 fill/copy/erase/modify rectangular regions (DECFRA, DECCRA, etc.)
  • Scrolling Regions - DECSTBM for restricted scrolling areas
  • Tab Stops - Configurable tab stops (HTS, TBC, CHT, CBT)
  • Unicode Support - Full Unicode including complex emoji sequences and grapheme clusters
    • Variation selectors (emoji vs text presentation)
    • Skin tone modifiers (Fitzpatrick scale U+1F3FB-U+1F3FF)
    • Zero Width Joiner (ZWJ) sequences for multi-emoji glyphs
    • Regional indicators for flag emoji
    • Combining characters and diacritical marks

Modern Features

  • Alternate Screen Buffer - Full support with automatic cleanup
  • Mouse Support - Multiple tracking modes and encodings (X10, Normal, Button, Any, SGR, URXVT)
  • Bracketed Paste Mode - Safe paste handling
  • Focus Tracking - Focus in/out events
  • OSC 8 Hyperlinks - Clickable URLs in terminal (full TUI support)
  • OSC 52 Clipboard - Copy/paste over SSH without X11
  • OSC 9/777/99 Notifications - Desktop-style alerts and notifications, including Kitty's OSC 99 protocol (chunked payloads, urgency levels, actions) via take_notifications_detailed()
  • Terminal Capability Queries - XTGETTCAP (DCS + q) capability lookup and DECRQSS (DCS $ q) SGR/cursor-style/scroll-margin introspection
  • Expanded XTWINOPS Reporting - CSI 11/13/19 t report window state, position, and screen size in characters
  • Shell Integration - OSC 133 (iTerm2/VSCode compatible), OSC 1337 RemoteHost for remote host detection
  • Semantic Buffer Zones - OSC 133 FinalTerm markers partition scrollback into prompt, command, and output zones
  • Command Output Capture - Extract text from specific command execution blocks via get_command_output() and get_command_outputs()
  • Semantic Snapshot API - Structured terminal state extraction via get_semantic_snapshot() for AI/LLM consumption, with configurable scope (visible, recent, full) and JSON output
  • Kitty Keyboard Protocol - Progressive keyboard enhancement with auto-reset on alternate screen exit
  • Synchronized Updates (DEC 2026) - Flicker-free rendering
  • Tmux Control Protocol - Control mode integration support
  • Observer API - Push-based event delivery with sync callbacks and async queues; convenience wrappers for common patterns (bell, title, CWD, command completion, zone changes)
  • General-purpose File Transfer - OSC 1337 File= with inline=0 for host-to-terminal downloads, RequestUpload for terminal-to-host uploads, with progress tracking and lifecycle events
  • Instant Replay - Cell-level terminal snapshots with input-stream delta recording, size-based eviction, and timeline navigation via SnapshotManager and ReplaySession
  • C-Compatible FFI - embedding API in include/terminal_core.h (ptec_terminal_create/feed/dirty_ranges/read_row render loop, key encoding, snapshots, observers; SharedState/SharedCell) for C/C++ and Swift apps — see the FFI Guide and make xcframework for iOS

Graphics Support

  • Sixel Graphics - DEC VT340 compatible bitmap graphics with half-block rendering
  • iTerm2 Inline Images - OSC 1337 protocol for PNG, JPEG, GIF images
  • Kitty Graphics Protocol - APC G protocol with image reuse, animations, zlib compression (o=z), and advanced placement; the t=f/t=t file media is security-gated (set_allow_file_media, default allows only spec-named *tty-graphics-protocol* temp files, deleted only after decoding)
  • Unicode Placeholders - Virtual placements insert U+10EEEE characters for inline image display
  • Unified Graphics Store - Protocol-agnostic storage with scrollback support
  • Animation Support - Frame-based animations with timing and composition control
  • Resource Management - Configurable memory limits and graphics dropped tracking

PTY Support

  • Interactive Shell Sessions - Spawn and control shell processes
  • Bidirectional I/O - Send input and receive output
  • Process Management - Start, stop, and monitor child processes
  • Dynamic Resizing - Resize with SIGWINCH signal
  • Environment Control - Custom environment variables and working directory
  • Event Loop Integration - Non-blocking update detection
  • Cross-Platform - Linux, macOS, and Windows via portable-pty

Terminal Streaming (WebSocket)

  • Standalone Server - Pure Rust streaming server binary (no Python required)
  • Real-time Streaming - Sub-100ms latency terminal streaming over WebSocket
  • Multiple Clients - Support for concurrent viewers per session
  • Authentication - Optional API key authentication (header or URL param)
  • Configurable Themes - Multiple built-in color themes (iTerm2, Monokai, Dracula, Solarized)
  • Auto-resize - Client-initiated terminal resizing with SIGWINCH support
  • Browser Compatible - Works with any WebSocket client (xterm.js recommended)
  • Modern Web Frontend - Next.js/React application with Tailwind CSS v4 and xterm.js

Terminal Multiplexer (par-mux)

  • tmux Control Mode - Sessions, windows, and split panes served over a local socket, attachable by tmux control-mode clients
  • Real-Time Push - Pane output streams to clients as bytes arrive; no polling
  • Agent Awareness - Panes report agent state over the same socket (JSON hook reports), with a scrape fallback for agents without hooks and an agent roster query
  • Session Resume - Agent session identity persists across daemon restarts; agent panes respawn through their resume invocations
  • Attach Client - par-mux attach renders sessions in your terminal (render mode, the default) or byte-pumps one pane (passthrough), with workspaces, a sidebar, and a config file; see docs/MUX.md
  • Crash-Safe State - Atomic saves with quarantine of unreadable state files; a clean SIGTERM never loses the last window

Standalone Binary Updates

Both par-term-streamer and par-mux support --check-update (report only) and --self-update (install and restart). Updates use this repository's GitHub releases, require SHA-256 checksum sidecars, and retain a .previous binary beside the installation. Automatic installation is off by default. Enable streamer --auto-update or mux [daemon] auto-update = true, with an hourly, daily (default), or weekly interval. See streamer configuration and mux configuration for restart behavior and the app-bundle guard.

Screenshots and Export

  • Multiple Formats - PNG, JPEG, BMP, SVG (vector); HTML via export_html()
  • Embedded Font - JetBrains Mono bundled - no installation required
  • Programming Ligatures - =>, !=, >=, and other code ligatures
  • True Font Rendering - High-quality antialiasing for raster formats
  • Color Emoji Support - Full emoji rendering with automatic font fallback
  • Session Recording - Record/replay sessions (asciicast v2, JSON)
  • Export Functions - Plain text, ANSI styled, HTML export

Macro Recording and Playback

  • YAML Format - Human-readable macro storage format
  • Friendly Key Names - Intuitive key combinations (ctrl+shift+s, enter, f1, etc.)
  • Keyboard Events - Record and replay keyboard input with precise timing
  • Delays - Control timing between events
  • Screenshot Triggers - Trigger screenshots during playback
  • Playback Controls - Play, pause, resume, stop, and speed control
  • Macro Library - Store and manage multiple macros
  • Recording Conversion - Convert terminal recording sessions to macros

Utility Functions

  • Text Extraction - Smart word/URL detection, selection boundaries, bracket matching
  • Content Search - Find text with case-sensitive/insensitive matching
  • Buffer Statistics - Memory usage, cell counts, graphics count and memory tracking
  • Color Utilities - 18+ color manipulation functions (iTerm2-compatible)
    • NTSC brightness, contrast adjustment, WCAG accessibility checks
    • Color space conversions (RGB, HSL, Hex, ANSI 256)
    • Saturation/hue adjustment, color mixing

Documentation

Installation

From PyPI

uv add par-term-emu-core-rust
# or
pip install par-term-emu-core-rust

Wheels ship with the streaming server compiled in (StreamingServer works out of the box; check par_term_emu_core_rust._native.HAS_STREAMING to detect a build without it).

From Source

Requires Rust 1.99+ and Python 3.12+:

# Install maturin (build tool)
uv tool install maturin

# Build and install
maturin develop --release

Building a Wheel

# streaming is included: pyproject.toml [tool.maturin] features apply to every maturin build
maturin build --release
uv add --find-links target/wheels par-term-emu-core-rust
# or
pip install target/wheels/par_term_emu_core_rust-*.whl

Using as a Rust Library

The library can be used in pure Rust projects without Python. Choose your feature combination:

Use Case Command What's Included
Rust Only cargo add par-term-emu-core-rust --no-default-features --features pty_session Terminal, PTY, Macros
Rust + Streaming cargo add par-term-emu-core-rust --no-default-features --features streaming,pty_session + WebSocket/HTTP server
Python Only cargo add par-term-emu-core-rust + Python bindings
Everything cargo add par-term-emu-core-rust --features full All features

Note: Since v0.46.0 the pty_session module (real PTY backend) is a separate feature. Omit it only for headless use without PtySession. See docs/RUST_USAGE.md for details.

Download pre-built streaming server (recommended):

Pre-built binaries and web frontend packages are available from GitHub Releases:

# Download binary (Linux example)
wget https://github.com/paulrobello/par-term-emu-core-rust/releases/latest/download/par-term-streamer-linux-x86_64
chmod +x par-term-streamer-linux-x86_64

# Download web frontend (asset named par-term-web-frontend-v<version>.tar.gz from
# https://github.com/paulrobello/par-term-emu-core-rust/releases/latest)
mkdir -p ./web_term
tar -xzf par-term-web-frontend-v*.tar.gz -C ./web_term

# Run
./par-term-streamer-linux-x86_64 --web-root ./web_term

Available binaries: Linux (x86_64, ARM64), macOS (Intel, Apple Silicon), Windows (x86_64)

Pre-built par-mux daemon binaries (standalone: no Python, no par-term installation) are attached to the same GitHub Releases as par-mux-v<version>-<target>.tar.gz (Unix) / .zip (Windows) archives with a SHA256SUMS file. Per-platform install steps: docs/MUX.md.

Or install from crates.io:

# Streaming server (no-default-features is required: the default python feature
# links libpython and fails at link time for a standalone binary)
cargo install par-term-emu-core-rust --no-default-features --features streaming-bin --bin par-term-streamer

# Terminal multiplexer daemon with the attach client (the standalone par-mux crate):
cargo install par-mux --features mux-bin,attach

Or build them from a source checkout (drop ,attach for the daemon alone):

cargo install --path crates/par-mux --features mux-bin,attach --locked

Or build from source:

cargo build --bin par-term-streamer --no-default-features --features streaming-bin --release
./target/release/par-term-streamer --help

See docs/RUST_USAGE.md for detailed Rust API documentation and examples.

Embedding in iOS Apps

The core ships a C API (src/ffi.rs, header include/terminal_core.h) for on-device embedding — the same emulator as par-term, packaged as a static xcframework for iOS device and simulator:

# Requires Xcode + rustup target add aarch64-apple-ios aarch64-apple-ios-sim
make xcframework
# → target/xcframework/TerminalCore.xcframework

TerminalCore.xcframework (device + simulator slices) is attached to GitHub releases from 0.56.0 on; build it locally with make xcframework for unreleased commits. Each slice carries a Modules/module.modulemap, so after adding the xcframework to an Xcode project a Swift file just does import TerminalCore (the C header is re-exported; no bridging header needed).

The C surface is a full embedding API, not just snapshots (contracts and examples in the FFI Guide):

  • Version check: ptec_terminal_abi_version — compare against the header's TERM_CORE_ABI_VERSION at startup
  • Lifecycle/input: ptec_terminal_create / ptec_terminal_free / ptec_terminal_feed (VT bytes) / ptec_terminal_resize
  • Damage: ptec_terminal_dirty_ranges returns coalesced inclusive dirty-row ranges and ptec_terminal_mark_clean consumes them; independent renderers use ptec_terminal_damage_generation + ptec_terminal_dirty_ranges_since, so one consumer never hides damage from another
  • Scroll-aware damage (ABI v5): ptec_terminal_scroll_delta_since + ptec_terminal_content_dirty_ranges_since report a region's net scroll plus only the content-changed rows, so a renderer blits on scroll and redraws just the new rows
  • Pinned readback: ptec_terminal_read_row / ptec_terminal_read_scrollback_row / ptec_terminal_scrollback_count copy cells into caller-owned buffers — no allocation, no full-grid copy per frame — with palette-resolved colors and default-color bits (ABI v4); ptec_terminal_read_cell_grapheme returns a cell's full grapheme cluster; ptec_terminal_scrollback_total_scrolled pairs with the count to sync a mirrored scrollback window; ptec_terminal_get_cursor / ptec_terminal_get_modes carry per-frame state
  • Key encoding: ptec_terminal_encode_key turns key events into PTY bytes (xterm legacy, kitty level-1 disambiguate, and modifyOtherKeys, honoring application cursor keys and the negotiated kitty flags); ptec_terminal_encode_key_ex adds per-side macOS Option-key modes through TermKeyOptions
  • Snapshots and observers: ptec_terminal_get_state / ptec_terminal_free_state, ptec_terminal_add_observer / ptec_terminal_remove_observer; the on_event_v2 slot delivers structured TermEvents (a TERM_EVENT_* kind plus a JSON payload)

Optional Components

Terminfo Installation

For optimal terminal compatibility, install the par-term terminfo definition:

# Install for current user
./terminfo/install.sh

# Or install system-wide
sudo ./terminfo/install.sh --system

# Then use
export TERM=par-term
export COLORTERM=truecolor

See terminfo/README.md for details.

Shell Integration

Enhances terminal with semantic prompt markers, command status tracking, and smart selection:

cd shell_integration
./install.sh  # Auto-detects bash/zsh/fish

See shell_integration/README.md for details.

Quick Start

Basic Terminal Emulation

from par_term_emu_core_rust import Terminal

# Create terminal
term = Terminal(80, 24)

# Process ANSI sequences
term.process_str("Hello, \x1b[31mWorld\x1b[0m!\n")
term.process_str("\x1b[1;32mBold green text\x1b[0m\n")

# Get content and cursor position
print(term.content())
col, row = term.cursor_position()
print(f"Cursor at: ({col}, {row})")

PTY (Interactive Shell)

from par_term_emu_core_rust import PtyTerminal

# Create PTY terminal and spawn shell
with PtyTerminal(80, 24) as term:
    term.spawn_shell()

    # Send commands
    term.write_str("echo 'Hello from shell!'\n")
    # Block until the output actually lands — no sleep guessing
    term.wait_for_text("Hello from shell!", timeout=3.0)

    # Get output
    print(term.content())

    # Resize terminal
    term.resize(100, 30)

    # Exit shell
    term.write_str("exit\n")
# Automatic cleanup

Environment Variables and Working Directory

Pass environment variables and working directory directly to spawn_shell() without modifying the parent process environment. This is safe for multi-threaded applications (e.g., Tokio):

from par_term_emu_core_rust import PtyTerminal

# Spawn with custom environment variables
with PtyTerminal(80, 24) as term:
    term.spawn_shell(env={"MY_VAR": "hello", "DEBUG": "1"})
    term.write_str("echo $MY_VAR\n")  # Outputs: hello

# Spawn with custom working directory
with PtyTerminal(80, 24) as term:
    term.spawn_shell(cwd="/tmp")
    term.write_str("pwd\n")  # Outputs: /tmp

# Combine both
with PtyTerminal(80, 24) as term:
    term.spawn_shell(env={"PROJECT": "myapp"}, cwd="/home/user/projects")

The spawn() method also accepts env and cwd parameters:

term.spawn("/bin/bash", ["-c", "echo $MY_VAR"], env={"MY_VAR": "test"}, cwd="/tmp")

Screenshots

term = Terminal(80, 24)
term.process_str("\x1b[1;31mHello, World!\x1b[0m\n")

# Save screenshot
term.screenshot_to_file("output.png")
term.screenshot_to_file("output.svg", format="svg")  # Vector graphics!
open("output.html", "w").write(term.export_html(include_styles=True))  # Styled HTML

# Custom configuration
term.screenshot_to_file(
    "output.png",
    font_size=16.0,
    padding=20,
    include_scrollback=True,
    minimum_contrast=0.5,  # iTerm2-compatible contrast adjustment
)

Color Utilities

from par_term_emu_core_rust import (
    perceived_brightness_rgb,
    adjust_contrast_rgb,
    contrast_ratio,
    meets_wcag_aa,
    rgb_to_hex,
    hex_to_rgb,
    mix_colors,
)

# iTerm2-compatible contrast adjustment
adjusted = adjust_contrast_rgb((64, 64, 64), (0, 0, 0), 0.5)

# WCAG accessibility checks
ratio = contrast_ratio((0, 0, 0), (255, 255, 255))
print(f"Contrast ratio: {ratio:.1f}:1")
print(f"Meets WCAG AA: {meets_wcag_aa((0, 0, 0), (255, 255, 255))}")

# Color conversions
hex_color = rgb_to_hex((255, 128, 64))  # "#FF8040"
rgb = hex_to_rgb("#FF8040")  # (255, 128, 64)
mixed = mix_colors((255, 0, 0), (0, 0, 255), 0.5)  # Purple

Macro Recording and Playback

from par_term_emu_core_rust import Macro, PtyTerminal
import time

# Create a macro manually
macro = Macro("git_status")
macro.set_description("Check git status and show branch")
macro.add_key("g")
macro.add_key("i")
macro.add_key("t")
macro.add_key("space")
macro.add_key("s")
macro.add_key("t")
macro.add_key("a")
macro.add_key("t")
macro.add_key("u")
macro.add_key("s")
macro.add_key("enter")
macro.add_delay(500)  # Wait 500ms
macro.add_screenshot("git_status.png")  # Trigger screenshot

# Save to YAML
macro.save_yaml("git_status.yaml")

# Load and play back
term = PtyTerminal(80, 24)
term.spawn_shell()

# Load macro from file
loaded_macro = Macro.load_yaml("git_status.yaml")
term.load_macro("git_check", loaded_macro)

# Play the macro
term.play_macro("git_check", speed=1.0)  # Normal speed

# Tick to execute macro events
while term.is_macro_playing():
    if term.tick_macro():  # Returns True if event was processed
        time.sleep(0.01)  # Small delay for visual effect

    # Check for screenshot triggers
    triggers = term.get_macro_screenshot_triggers()
    for label in triggers:
        term.screenshot_to_file(label)

# Convert a recording to a macro
term.start_recording("test session")
term.write_str("ls -la\n")
time.sleep(0.5)
session = term.stop_recording()

# Convert and save
macro = term.recording_to_macro(session, "ls_command")
macro.save_yaml("ls_command.yaml")

Examples

See the examples/ directory for comprehensive examples:

Basic Examples

  • basic_usage_improved.py - Enhanced basic usage
  • colors_demo.py - Color support
  • cursor_movement.py - Cursor control
  • text_attributes.py - Text styling
  • unicode_emoji.py - Unicode/emoji support
  • scrollback_demo.py - Scrollback buffer usage

Advanced Features

  • alt_screen.py - Alternate screen buffer
  • mouse_tracking.py - Mouse events
  • bracketed_paste.py - Bracketed paste
  • synchronized_updates.py - Flicker-free rendering
  • shell_integration.py - OSC 133 integration
  • test_osc52_clipboard.py - SSH clipboard
  • test_kitty_keyboard.py - Kitty keyboard protocol
  • hyperlink_demo.py - Clickable URLs
  • notifications.py - Desktop notifications
  • rectangle_operations.py - VT420 rectangle ops

Graphics and Export

  • display_image_sixel.py - Sixel graphics
  • test_sixel_simple.py - Simple sixel examples
  • test_sixel_display.py - Advanced sixel display
  • screenshot_demo.py - Screenshot features
  • feature_showcase.py - Comprehensive TUI showcase

PTY Examples

  • pty_basic.py - Basic PTY usage
  • pty_shell.py - Interactive shells
  • pty_resize.py - Dynamic resizing
  • pty_event_loop.py - Event loop integration
  • pty_mouse_events.py - Mouse in PTY
  • pty_custom_env.py - Custom environment variables
  • pty_multiple.py - Multiple PTY sessions
  • pty_with_par_term.py - Integration with par-term

Terminal Streaming

  • streaming_demo.py - Python WebSocket streaming server
  • streaming_client.html - Browser-based terminal client

Macros and Automation

  • demo.yaml - Example macro definition

Standalone Rust Server:

# Build and run (default: ws://127.0.0.1:8099)
make streamer-run

# Run with authentication
make streamer-run-auth

# Or use cargo directly
cargo build --bin par-term-streamer --no-default-features --features streaming-bin --release
./target/release/par-term-streamer --port 8099 --theme dracula

# With authentication (prefer the env var: a CLI argument is readable in
# ps and shell history for the server's lifetime)
export PAR_TERM_API_KEY=my-secret
./target/release/par-term-streamer --theme monokai

# With system resource stats (CPU, memory, disk, network)
./target/release/par-term-streamer --enable-system-stats --system-stats-interval 5

# Install globally
make streamer-install
par-term-streamer --help

Available Themes: iterm2-dark, monokai, dracula, solarized-dark

Diagnostics and Test Scripts

  • bce_scroll_test.py - Background color erase (BCE) during scrolling
  • char_test.py - Character-specific rendering test
  • gradient_test.py - Minimal gradient test for terminal wrap behavior
  • rich_mimic_test.py - Rich-style output rendering test
  • scroll_timing_test.py - Scroll timing test
  • streaming_debug.py - Streaming server debug tool
  • test_tui_clipboard.py - TUI clipboard and selection features
  • test_underline_styles.py - Underline styles (SGR 4:x)
  • render_utils.py - Rendering helpers imported by the other examples (not run directly)

Web Terminal Frontend

Using Pre-built Package (Recommended):

Download the pre-built static web frontend from GitHub Releases:

# Download and extract (asset named par-term-web-frontend-v<version>.tar.gz from
# https://github.com/paulrobello/par-term-emu-core-rust/releases/latest)
mkdir -p ./web_term
tar -xzf par-term-web-frontend-v*.tar.gz -C ./web_term

# Run streamer with web frontend
par-term-streamer --web-root ./web_term
# Open browser to http://localhost:8099

See web-terminal-frontend/README.md for detailed usage instructions.

Building from Source:

A modern Next.js-based web terminal frontend source is in web-terminal-frontend/:

# Install dependencies (bun)
make web-install

# Development server on http://localhost:3000
make web-dev

# Static build copied to web_term/ for par-term-streamer --web-root
make web-build-static

Features:

  • Modern UI with Tailwind CSS v4
  • xterm.js terminal emulator
  • WebSocket connection to streaming server
  • Theme selection and synchronization
  • Responsive design
  • Terminal resize support
  • Customizable UI theme - Edit theme.css after build (no rebuild required)

See web-terminal-frontend/README.md for detailed setup and configuration.

TUI Demo Application

A full-featured TUI (Text User Interface) application is available in the sister project par-term-emu-tui-rust.

TUI Demo Application

Installation: uv add par-term-emu-tui-rust or pip install par-term-emu-tui-rust

GitHub: https://github.com/paulrobello/par-term-emu-tui-rust

Technology

  • Rust (1.99+) - Core library implementation
  • Python (3.12+) - Python bindings
  • PyO3 - Zero-cost Python/Rust bindings
  • VTE - ANSI sequence parsing
  • portable-pty - Cross-platform PTY support

Running Tests

# All tests: Rust, Rust streaming, and Python (rebuilds the extension first)
make test

# Rust tests only (plain `cargo test` fails to link under the default `python` feature)
make test-rust

# Python tests only (runs `make dev` first)
make test-python

Performance

  • Zero-copy operations where possible
  • Efficient grid representation
  • Fast ANSI parsing with VTE crate
  • Minimal Python/Rust boundary crossings

See docs/ARCHITECTURE.md for implementation details.

Security

When using PTY functionality, follow security best practices to prevent command injection and other vulnerabilities.

See docs/SECURITY.md for comprehensive security guidelines.

Contributing

Contributions are welcome! Please submit issues or pull requests on GitHub.

Development Setup

git clone https://github.com/paulrobello/par-term-emu-core-rust.git
cd par-term-emu-core-rust
make setup-venv  # Create virtual environment
make pre-commit-install  # Install pre-commit hooks (recommended)
make dev  # Build library
make checkall  # Run all quality checks

Code Quality

All contributions must pass:

  • Rust formatting (cargo fmt)
  • Rust linting (cargo clippy)
  • Python formatting (make fmt-python)
  • Python linting (make lint-python)
  • Type checking (pyright)
  • Tests (make test-python)

TIP: Use make pre-commit-install to automate all checks on every commit!

Load-Sensitive Tests

Timing-dependent Rust tests (the PTY and attach integration suites, and render tests pinned to timing) are labeled #[ignore = "load-sensitive ..."]. A plain cargo test and make checkall skip them, and make test-rust prints how many it deferred. Run them as follows:

  • make test-rust-sensitive runs exactly the labeled set.
  • make checkall-ci includes them (its nextest legs run ignored tests too), so it is the gate to pass before pushing a change that touches a labeled test.
  • To run one suite by hand, pass --include-ignored, for example cargo test -p par-mux --features mux-bin,attach --test mux_attach -- --include-ignored --test-threads=1.

These tests measure wall-clock behavior, so run them on a quiet machine. Under heavy host load a failure is usually a timing flake rather than a regression, so re-run on an idle host before debugging.

See CONTRIBUTING.md for the contribution workflow, and CLAUDE.md for detailed development instructions.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Author

Paul Robello - probello@gmail.com

Metadata

Release files for par-term-emu-core-rust 0.82.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for par-term-emu-core-rust 0.82.0
File Size Uploaded Provenance Actions
par_term_emu_core_rust-0.82.0.tar.gz 4.2 MB With provenance Details for par_term_emu_core_rust-0.82.0.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for par-term-emu-core-rust 0.82.0
File Actions
par_term_emu_core_rust-0.82.0-cp314-cp314-win_amd64.whl CPython 3.14 CPython 3.14 Windows x86-64 Details for par_term_emu_core_rust-0.82.0-cp314-cp314-win_amd64.whl
par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.14 CPython 3.14 Linux glibc 2.17+ x86-64 Details for par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl CPython 3.14 CPython 3.14 Linux glibc 2.17+ ARM64 Details for par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_x86_64.whl CPython 3.14 CPython 3.14 macOS 10.12+ x86-64 Details for par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_x86_64.whl
par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl CPython 3.14 CPython 3.14 macOS 11.0+ ARM64, macOS 10.12+ x86-64, macOS 10.12+ universal2 (ARM64, x86-64) Details for par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl
par_term_emu_core_rust-0.82.0-cp313-cp313-win_amd64.whl CPython 3.13 CPython 3.13 Windows x86-64 Details for par_term_emu_core_rust-0.82.0-cp313-cp313-win_amd64.whl
par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.13 CPython 3.13 Linux glibc 2.17+ x86-64 Details for par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl CPython 3.13 CPython 3.13 Linux glibc 2.17+ ARM64 Details for par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_x86_64.whl CPython 3.13 CPython 3.13 macOS 10.12+ x86-64 Details for par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_x86_64.whl
par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl CPython 3.13 CPython 3.13 macOS 10.12+ universal2 (ARM64, x86-64), macOS 11.0+ ARM64, macOS 10.12+ x86-64 Details for par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl
par_term_emu_core_rust-0.82.0-cp312-cp312-win_amd64.whl CPython 3.12 CPython 3.12 Windows x86-64 Details for par_term_emu_core_rust-0.82.0-cp312-cp312-win_amd64.whl
par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.12 CPython 3.12 Linux glibc 2.17+ x86-64 Details for par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl CPython 3.12 CPython 3.12 Linux glibc 2.17+ ARM64 Details for par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_x86_64.whl CPython 3.12 CPython 3.12 macOS 10.12+ x86-64 Details for par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_x86_64.whl
par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl CPython 3.12 CPython 3.12 macOS 11.0+ ARM64, macOS 10.12+ x86-64, macOS 10.12+ universal2 (ARM64, x86-64) Details for par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl

Total release size: 124.1 MB

Release files / par_term_emu_core_rust-0.82.0.tar.gz

Download URL par_term_emu_core_rust-0.82.0.tar.gz
Size 4.2 MB
Tags Source
SHA-256 checksum
How to use checksums
6b9a12a16c4f06ee33df2fdd6e65adb649bf35e1060cb6edb298d27811d25865
BLAKE2b-256 checksum
How to use checksums
4b451551e49fbcefa41ce6feddbf9bf337866f338b0732c421f2d8a05d8f65d2
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp314-cp314-win_amd64.whl

Download URL par_term_emu_core_rust-0.82.0-cp314-cp314-win_amd64.whl
Size 6.5 MB
Tags CPython 3.14 Windows x86-64
SHA-256 checksum
How to use checksums
801e92ede6728894258d63e1666f83a703d830bff1aa879c00a7db9e2584f0c4
BLAKE2b-256 checksum
How to use checksums
95172bbbe38a6afce46ec15aa82a596adf0dbcf965ff6ef00f8a97b6b5977831
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 7.0 MB
Tags CPython 3.14 Linux glibc 2.17+ x86-64
SHA-256 checksum
How to use checksums
d6c36d3a61da58528ab038249416a70982ba2a96e651b4ccd6730431b954a15c
BLAKE2b-256 checksum
How to use checksums
de655a62f9b8ede315eecca558379533cf928d63335613b17cdeb360c5c09057
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

Download URL par_term_emu_core_rust-0.82.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
Size 6.7 MB
Tags CPython 3.14 Linux glibc 2.17+ ARM64
SHA-256 checksum
How to use checksums
aad96ea7f72fb5d19926055cedf4f251021407291b8e2511318fcf7b8723acb6
BLAKE2b-256 checksum
How to use checksums
4c04ff34d58ddfd6e258ea6f89298a184550243b1967b0860bafec9bbe9509f7
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_x86_64.whl

Download URL par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_x86_64.whl
Size 6.8 MB
Tags CPython 3.14 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
982a30bc481dd6246f3d8ecaa527698739ebdd6f268b279ead655227a825bb0b
BLAKE2b-256 checksum
How to use checksums
0d5ec984ffb84ca296661c6d0548055443641396525fa5e247d12dd87d4268ba
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl

Download URL par_term_emu_core_rust-0.82.0-cp314-cp314-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl
Size 13.1 MB
Tags CPython 3.14 macOS 10.12+ universal2 (ARM64, x86-64) macOS 10.12+ x86-64 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
cb3d84ce3f9a02071066e18476c7e438fdff57041544e96808c8eda78f276e6a
BLAKE2b-256 checksum
How to use checksums
d172cebe5a0b75ce80742d5f31637b39b51ca1dbee33b9ddfee8b288c3773444
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp313-cp313-win_amd64.whl

Download URL par_term_emu_core_rust-0.82.0-cp313-cp313-win_amd64.whl
Size 6.5 MB
Tags CPython 3.13 Windows x86-64
SHA-256 checksum
How to use checksums
939e738256c990eed69e76c0e4e3634ad280090d521c5c85bd449403386776d1
BLAKE2b-256 checksum
How to use checksums
ad7bc58eabaa345f7495e1056c852bdab2e1c15f369220f8998de73925fa7769
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 7.0 MB
Tags CPython 3.13 Linux glibc 2.17+ x86-64
SHA-256 checksum
How to use checksums
cb9d7bb0c1554872a6f970a82288ee62aedc863b12fbdc0758b275fb9f77467c
BLAKE2b-256 checksum
How to use checksums
6fccdeca721182f8b9b33fd6711f202080db5780544324cb1e242095ec1513b6
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

Download URL par_term_emu_core_rust-0.82.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
Size 6.7 MB
Tags CPython 3.13 Linux glibc 2.17+ ARM64
SHA-256 checksum
How to use checksums
cf9c879ddc6840e6205d7747b9edc6642a30c387e18d89d93a12861e082da3b6
BLAKE2b-256 checksum
How to use checksums
b89041541bf3a756b5539b874ffe69c34aeabf1edba2f01fb191357c0985d631
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_x86_64.whl

Download URL par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_x86_64.whl
Size 6.8 MB
Tags CPython 3.13 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
2ea7507af0b9fb8fdf82188093037343bb748c0e6be7dc8e859c13963c8e74fd
BLAKE2b-256 checksum
How to use checksums
f0e5fe35d3f87272ce3e002082b891a83df5f2c05117eb2230baf07849145f3e
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl

Download URL par_term_emu_core_rust-0.82.0-cp313-cp313-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl
Size 13.1 MB
Tags CPython 3.13 macOS 10.12+ universal2 (ARM64, x86-64) macOS 10.12+ x86-64 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
fb93c6b5e43fad1e2a97063b705efdf28d712b9032533f5d98d728a3b71d5571
BLAKE2b-256 checksum
How to use checksums
f1b955957f9708e5c091e74be78a03861933c9f288214ba1ba2cc5b04acd5374
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp312-cp312-win_amd64.whl

Download URL par_term_emu_core_rust-0.82.0-cp312-cp312-win_amd64.whl
Size 6.5 MB
Tags CPython 3.12 Windows x86-64
SHA-256 checksum
How to use checksums
421779133bed922195a847546e500d97eab4d09afc48b3544a4871061a32ed0f
BLAKE2b-256 checksum
How to use checksums
69bfcfc6c47825855e8f8aaa524439998ba3fe70b3f5a3c77f8873badb3c1413
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 7.0 MB
Tags CPython 3.12 Linux glibc 2.17+ x86-64
SHA-256 checksum
How to use checksums
6278d4c4c526850460cbae26f41c868c96ad065c67ba822a5cac09c7f8b4df51
BLAKE2b-256 checksum
How to use checksums
ba9da41b48900cba9f033023d4608c54da9a59ba6e4d2cee307a6d4fc71abb4c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

Download URL par_term_emu_core_rust-0.82.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
Size 6.7 MB
Tags CPython 3.12 Linux glibc 2.17+ ARM64
SHA-256 checksum
How to use checksums
138c9568af6ed88007844c713b0c3128fee520fffca033553638264d1532a324
BLAKE2b-256 checksum
How to use checksums
aef8a204cef6177610336a81da8136a33c248b4de45fff1ef7b23c4e42e18460
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_x86_64.whl

Download URL par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_x86_64.whl
Size 6.8 MB
Tags CPython 3.12 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
d4476c50fa66b49c867175f55e5cbe28aafa9e06c3f1e4dac41f9bd0d36ba4e3
BLAKE2b-256 checksum
How to use checksums
05546b57054bd00a4db03d8f378ed4b925a0ff3c75302071d68ced183aea668d
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl

Download URL par_term_emu_core_rust-0.82.0-cp312-cp312-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl
Size 13.1 MB
Tags CPython 3.12 macOS 10.12+ universal2 (ARM64, x86-64) macOS 10.12+ x86-64 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
cef539491f70e78af5acc4743bf833d4793eba82f113c577f2b6c768140d5516
BLAKE2b-256 checksum
How to use checksums
aac55cce5a5f2eddcfa9d917378c51896a2ffe335adde72b64c9b22553b45ea1
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Security for par-term-emu-core-rust 0.82.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

All 16 files in this release have been uploaded with provenance metadata.

Select from 16 files

Attestation for par_term_emu_core_rust-0.82.0.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.82.0 This release

16 release files Full provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page