GitHub - 0-AI-UG/cate · GitHub

Skip to content

Navigation Menu

Toggle navigation

Sign in

Appearance settings

PlatformAI CODE CREATIONGitHub CopilotWrite better code with AIGitHub SparkBuild and deploy intelligent appsGitHub ModelsManage and compare promptsMCP RegistryNewIntegrate external toolsDEVELOPER WORKFLOWSActionsAutomate any workflowCodespacesInstant dev environmentsIssuesPlan and track workCode ReviewManage code changesAPPLICATION SECURITYGitHub Advanced SecurityFind and fix vulnerabilitiesCode securitySecure your code as you buildSecret protectionStop leaks before they startEXPLOREWhy GitHubDocumentationBlogChangelogMarketplaceView all featuresSolutionsBY COMPANY SIZEEnterprisesSmall and medium teamsStartupsNonprofitsBY USE CASEApp ModernizationDevSecOpsDevOpsCI/CDView all use casesBY INDUSTRYHealthcareFinancial servicesManufacturingGovernmentView all industriesView all solutionsResourcesEXPLORE BY TOPICAISoftware DevelopmentDevOpsSecurityView all topicsEXPLORE BY TYPECustomer storiesEvents & webinarsEbooks & reportsBusiness insightsGitHub SkillsSUPPORT & SERVICESDocumentationCustomer supportCommunity forumTrust centerPartnersView all resourcesOpen SourceCOMMUNITYGitHub SponsorsFund open source developersPROGRAMSSecurity LabMaintainer CommunityAcceleratorGitHub StarsArchive ProgramREPOSITORIESTopicsTrendingCollectionsEnterpriseENTERPRISE SOLUTIONSEnterprise platformAI-powered developer platformAVAILABLE ADD-ONSGitHub Advanced SecurityEnterprise-grade security featuresCopilot for BusinessEnterprise-grade AI featuresPremium SupportEnterprise-grade 24/7 supportPricing

Search or jump to...

Search code, repositories, users, issues, pull requests...

Search

Clear

Search syntax tips

Provide feedback

We read every piece of feedback, and take your input very seriously.

Include my email address so I can be contacted

Cancel

Submit feedback

Saved searches

Use saved searches to filter your results more quickly

Name

Query

To see all available qualifiers, see our documentation.

Cancel

Create saved search

Sign in

Sign up

Appearance settings

Resetting focus

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

0-AI-UG

/

cate

Public

Notifications
You must be signed in to change notification settings

Fork
31

Star
406

Code

Issues
1

Pull requests
1

Actions

Projects

Security and quality
0

Insights

Additional navigation options

Code

Issues

Pull requests

Actions

Projects

Security and quality

Insights

0-AI-UG/cate

 mainBranchesTagsGo to fileCodeOpen more actions menuFolders and filesNameNameLast commit messageLast commit dateLatest commit History302 Commits302 Commits.github/workflows.github/workflows  assetsassets  buildbuild  e2ee2e  scriptsscripts  srcsrc  .gitignore.gitignore  .nvmrc.nvmrc  CHANGELOG.mdCHANGELOG.md  CLAUDE.mdCLAUDE.md  CONTRIBUTING.mdCONTRIBUTING.md  LICENSELICENSE  README.mdREADME.md  electron-builder.ymlelectron-builder.yml  electron.vite.config.tselectron.vite.config.ts  index.htmlindex.html  package-lock.jsonpackage-lock.json  package.jsonpackage.json  playwright.config.tsplaywright.config.ts  postcss.config.jspostcss.config.js  tailwind.config.tstailwind.config.ts  tsconfig.jsontsconfig.json  tsconfig.node.jsontsconfig.node.json  vitest.config.tsvitest.config.ts  View all filesRepository files navigationREADMEContributingMIT license

Cate

A spatial desktop IDE with an infinite canvas for code, terminals, browsers, documents, AI agents, and git.

Current source version: v1.0.3

Cate is an Electron desktop app for arranging development tools in freeform space. Mix floating canvas panels with docked tabs and splits, detach panels into standalone windows, and keep multiple workspaces synced across sessions.
Getting Started
Open any folder to create a workspace — Cate restores your canvas layout, panel positions, and open terminals every time you come back. Right-click the canvas to add panels, press Cmd+K for the command palette, or drag panels onto the dock to create tabs and splits.
No configuration files, no project setup — just point Cate at a directory and start working.
Why Cate?
Alt-tab works fine — until you have 12 terminals, 6 files open, docs in another window, and notes scattered across desktops. At that point switching windows becomes the actual bottleneck.
Cate replaces that pile of windows with one persistent canvas per project. Terminals, editors, browsers, and notes sit where you put them, grouped how you think about them, and they're still there when you come back the next day.

Cate is not a window manager replacement. Tiling/scrolling WMs (Hyprland, Niri, GlazeWM, KDE) are great if you mainly want to arrange OS windows. Cate is a spatial canvas around a single project's tools — closer to Figma's infinite canvas than to a WM.

Features
🎨 Canvas & Layout

Infinite canvas — zoom, pan, and arrange panels anywhere in freeform space. Pan with two-finger drag or right-click drag; zoom with Cmd+scroll or the canvas controls.
Dock system — drag floating panels onto the dock to create tabs and splits. Each dock zone (center, left, right, bottom) can hold multiple tabs with type-colored icons.
Detached windows — pull panels or full dock layouts into separate OS windows.
Saved layouts — name, save, load, and delete canvas arrangements (nodes and regions) from an in-app modal (Cmd+K → "Saved Layouts…").
Multi-workspace sessions — keep several projects open and restore them on restart. Switch between workspaces from the sidebar.

💻 Code, Docs & Terminals

Monaco Editor panels — full VS Code-grade editing with syntax highlighting, multi-cursor, find/replace, diff support, and Markdown Preview/Source mode with GFM rendering. Scratch editors persist unsaved content across sessions.
Persistent editor buffers — file-backed models are reused across panels, and scratch editor content persists with the session.
Document panels — native canvas viewers for PDFs, DOCX files, and images, with file type detection backed by magic-byte checks.
Native terminals — xterm.js with WebGL rendering, backed by node-pty PTYs rooted in the active workspace. Shell auto-detection with graceful fallback if the configured shell is unavailable.
Browser panels — embedded webview panels for previewing documentation, dev servers, or any URL. Context-isolated with hardened security settings.

🔧 Git & Source Control

Git-aware file explorer — file tree with live filesystem watching, tracked/untracked dimming, search, and copy/paste for files and folders with collision-safe renaming.
Source control sidebar — stage/unstage, branch management, worktrees, commit history, and inline diff views. Git monitor polls and surfaces changes automatically.
Project-wide search — full-text search across workspace files with instant results.

🤖 AI Agent

Pi Agent panel — run an in-app coding agent powered by @earendil-works/pi-agent-core, with chat threads, per-chat model restore, and workspace-aware panel placement.
Provider auth & models — connect OAuth providers such as Anthropic, OpenAI Codex, and GitHub Copilot, or API-key providers such as OpenAI, Google Gemini, OpenRouter, Groq, Mistral, DeepSeek, and more.
Marketplace & plan mode — install Pi extensions from the marketplace and use Cate's bundled plan-mode helper for agent-guided implementation planning.

🔍 Search & Navigation

Canvas-wide search (Cmd+Shift+F) — Spotlight-style overlay that searches workspace files, live terminal scrollback, and open panel titles/paths in one place. Recent-focus ranked results with colored type-tile icons.
Panel switcher (Ctrl+Space) — compact keyboard overlay for jumping between open canvas panels and centering the selected node.
Command palette (Cmd+K) — quick access to commands, open panels, and workspace files. Unified Spotlight-style chrome across all overlays.

🖥️ Desktop Polish

Auto-save & session restore — all panel state, positions, and open files persist automatically.
Optional macOS native window tabs — group Cate windows in the system tab bar.
Auto-update checks — checks GitHub releases and notifies when a new version is available.
Crash resilience — Sentry diagnostics, session restore validation, shell fallback banners in the PTY, and guarded update/restart flows help prevent noisy or looping crash states.

Install
If you just want to use Cate, download a prebuilt release — don't build from source. This repository currently targets v1.0.3.

Platform
Formats
Link

macOS
DMG, ZIP (arm64, x64)
Latest release

Windows
NSIS installer, ZIP (x64)
Latest release

Linux
AppImage, DEB, tar.gz (x64)
Latest release

macOS note: release builds are notarized and configured for hardened runtime. Unsigned local or test builds may require:
xattr -cr /Applications/Cate.app

Linux note: on Steam Deck or other read-only-root distros, prefer the tar.gz portable build. If the AppImage fails to launch, try --no-sandbox as a fallback (e.g. ./Cate.AppImage --no-sandbox).

Build from Source

The steps below are for contributors — use the prebuilt release above for daily use.

Prerequisites

Node.js 20 or 22 LTS (see .nvmrc). Node 23+ is not supported; node-pty has no prebuilds and native compilation will fail.
npm >= 9
Python 3 and a C++ compiler (for node-pty native module)

macOS: Xcode Command Line Tools (xcode-select --install)
Debian/Ubuntu: sudo apt install build-essential python3
Fedora/RHEL: sudo dnf install @development-tools gcc-c++ make python3
Arch: sudo pacman -S base-devel python
Windows: Visual Studio Build Tools (select the "Desktop development with C++" workload)

Setup
git clone https://github.com/0-AI-UG/cate.git
cd cate
npm install
Development
npm run dev
This starts the Electron app with hot reload via electron-vite.
Quality Checks
npm run typecheck
npm test # unit tests (vitest)
npm run test:e2e # Playwright integration tests
For the Electron smoke test harness:
npm run test:smoke:electron
Production Build
npm run build
Package for Distribution
npm run package
# or target one platform:
npm run package:mac
npm run package:win
npm run package:linux
Packaged binaries will be in the release/ directory.
Security & Packaging
Cate uses a context-isolated preload bridge for all IPC communication. Filesystem access is scoped to registered workspace roots, browser panels use hardened webview settings with disabled node integration, and the updater falls back to opening the GitHub release page when a verified installer path is unavailable. Workspace-scoped allowedRoots validation prevents terminals from spawning outside approved directories.
Architecture
src/
├── agent/ # Embedded Pi coding-agent integration
│ ├── main/ # Agent process manager, auth, marketplace, session files
│ ├── renderer/ # Agent panel UI, chat thread, providers, model prefs
│ └── extensions/ # Bundled Cate plan-mode Pi extension
├── main/ # Electron main process
│ ├── ipc/ # IPC handlers (filesystem, git, terminal, menu, drag)
│ ├── analytics # Update/app event analytics helpers
│ ├── appContext # Shared main-process app state
│ ├── featureFlags # Runtime feature flags
│ ├── shellEnv # Login-shell environment capture
│ ├── shellResolver # Shell path resolution with fallback chain
│ ├── workspaceManager# Workspace lifecycle and session persistence
│ ├── workspaceRoots # Allowed-roots registration and validation
│ ├── windowRegistry # Window management (main, dock, detached)
│ ├── webSecurity # Webview hardening and CSP
│ ├── auto-updater # Update checks and release fetch
│ ├── sentry # Sentry integration
│ ├── store # electron-store persistence
│ ├── jsonFileStore # JSON-backed file persistence helpers
│ ├── menu # Application menu
│ └── sessionTrust # Session restore validation
├── preload/ # Context-isolated bridge exposed to the renderer
├── renderer/ # React 18 application
│ ├── assets/ # Renderer images and asset declarations
│ ├── canvas/ # Infinite canvas rendering, drag, resize, placement
│ ├── docking/ # Tabs, splits, detached dock windows, drag/drop
│ ├── drag/ # Cross-window drag-and-drop runtime and state
│ ├── panels/ # Terminal, Editor, Browser, Document, Git, Explorer,
│ │ # Projects, Canvas panel registry/components
│ ├── sidebar/ # Workspace, File Explorer, Source Control,
│ │ # Parallel Work, Project List, fileClipboard
│ ├── dialogs/ # Saved layouts and post-update feedback dialogs
│ ├── settings/ # Settings window sections and shortcut recorder
│ ├── ui/ # CommandPalette, GlobalSearch, NodeSwitcher,
│ │ # WelcomePage, ShortcutHintOverlay
│ ├── shells/ # Main, panel, and dock window shells
│ ├── stores/ # Zustand stores (canvas, app, dock, settings,
│ │ # shortcut, status, ui, update, url prompt)
│ ├── hooks/ # Custom React hooks (shortcuts, canvas interaction)
│ ├── lib/ # Utilities (coordinates, routing, terminal registry)
│ ├── workers/ # Monaco/editor workers
│ └── styles/ # Tailwind/global styles
└── shared/ # IPC channel definitions and shared TypeScript types

Tech Stack

Electron 41 — desktop shell (Chromium + Node.js)
React 18 — UI framework with functional components and hooks
Zustand 5 — lightweight state management (no Redux/Context)
Monaco Editor 0.52 — code editing (VS Code's editor component)
xterm.js 5.5 + node-pty 1.0 — terminal emulator with WebGL renderer
@earendil-works/pi packages — embedded coding-agent runtime, provider auth, and extension marketplace
pdf.js + mammoth — native PDF and DOCX document rendering
react-markdown + remark-gfm — Markdown preview with GitHub Flavored Markdown
simple-git 3.27 — git operations
chokidar 4.0 — filesystem watching
@phosphor-icons/react — app iconography
Tailwind CSS 3.4 — styling
electron-vite 5.0 — bundling with HMR
electron-builder 26 — packaging and distribution
electron-updater 6.8 — update checks
Sentry Electron 5 — crash reporting and diagnostics
Playwright — end-to-end integration tests
Vitest — unit test runner

Roadmap
Cate is under active development. For a detailed history of what changed in each release and a sense of where things are headed, see the CHANGELOG.
Star History

Contributing
See CONTRIBUTING.md for guidelines.
License
MIT

About

No description, website, or topics provided.

Resources

Readme

License

MIT license

Contributing

Contributing

Uh oh!

There was an error while loading. Please reload this page.

Activity

Custom properties
Stars

406
stars
Watchers

2
watching
Forks

31
forks

Report repository

Releases
45

v1.0.3

Latest

May 26, 2026

+ 44 releases

Packages
0

Uh oh!

There was an error while loading. Please reload this page.

Uh oh!

There was an error while loading. Please reload this page.

Contributors

Uh oh!

There was an error while loading. Please reload this page.

Languages

TypeScript
99.1%

Other
0.9%

Footer

© 2026 GitHub, Inc.

Footer navigation

Terms

Privacy

Security

Status

Community

Docs

Contact

Manage cookies

Do not share my personal information

You can’t perform that action at this time.

Cate is an Electron-based desktop application designed to serve as a spatial desktop IDE, offering an infinite canvas for arranging various development tools, including code editors, terminals, browsers, documents, and AI agents. The core philosophy of Cate is to alleviate the bottleneck created by traditional window management when handling numerous tools, proposing a freeform, spatial canvas approach for a single project. Unlike window managers that focus on arranging operating system windows, Cate functions as a spatial canvas around a project, drawing inspiration from concepts like Figma's infinite canvas.

The layout system is built around an infinite canvas where panels can be freely arranged, zoomed, and panned using gestures, allowing for spatially aware organization. This canvas is supported by a docked system where floating panels can be organized into tabs and splits, and these panel groupings can be detached into separate system windows. The application maintains session persistence through saved layouts, which allow users to save, load, and manage complex canvas arrangements, enabling multi-workspace sessions that can be restored upon system restart.

For handling development content, Cate incorporates specialized panels for various tasks. Code editing is managed through Monaco Editor panels, which provide VS Code-grade features such as syntax highlighting, multi-cursor functionality, diff support, and Markdown rendering. Persistent editor buffers ensure that file-backed models are reused across panels, and scratch editor content persists across sessions. Document panels serve as native viewers for PDFs, DOCX files, and images, utilizing file type detection based on magic-byte checks. Terminals are provided by xterm.js with WebGL rendering, integrated with node-pty, which handles process I/O and shell auto-detection. Browser panels offer context-isolated webviews for previewing documentation or running development servers.

Source control integration is handled via a Git-aware file explorer that features live filesystem watching, search capabilities, and collision-safe renaming for file and folder operations. A dedicated source control sidebar provides access to branch management, commit history, and inline diff views, with automatic monitoring of Git changes. Furthermore, the system supports project-wide search across all workspace files.

An integrated AI agent feature, the Pi Agent panel, allows users to run an in-app coding agent. This agent connects to various provider authentication methods, supporting external services such as Anthropic, OpenAI Codex, and various API key providers like Google Gemini or Groq. The agent also features chat threads, model restore capabilities, and a marketplace for installing extensions, supported by a plan-mode helper for guided implementation planning.

Navigation and interaction are streamlined through several overlays and commands. A canvas-wide search function allows users to spotlight files, terminal history, and panel titles in one location. A panel switcher provides a compact keyboard overlay for navigating between open panels. A comprehensive command palette offers unified access to commands, panel opening, and workspace file access.

Maintenance and polish are addressed through automatic state persistence, including auto-save and session restoration for all panel positions and open files. The application includes checks for updates against GitHub releases and implements crash resilience measures, utilizing Sentry diagnostics and shell fallback banners to manage potential error states.

The underlying technology stack is a contemporary set of tools, utilizing Electron as the desktop shell, React for the user interface, and Zustand for lightweight state management. Code editing relies on Monaco Editor, while terminals use xterm.js and node-pty, and document rendering employs pdf.js. The architecture is designed with strict security considerations, employing a context-isolated preload bridge for Inter-Process Communication, scoping filesystem access to registered workspace roots, and hardening webview settings. The project manages its complex structure by separating concerns across the main process, renderer process, and shared utilities, encapsulating agent logic, window management, and persistence within distinct modules.