# Getting started Source: https://athas.dev/docs Install Athas, open a project, and choose the guides for your development workflow. Athas is an open-source code editor for macOS, Windows, and Linux. It brings files, Git, terminals, databases, and AI agents into one workspace. Local editing does not require an account. ## Your first project 1. [Install Athas](https://athas.dev/docs/installation) for your operating system and CPU architecture. 2. Open a folder with `Cmd+O` on macOS or `Ctrl+O` on Windows and Linux, or drag it into Athas. 3. Open a file with `Cmd/Ctrl+P`, edit it, and save with `Cmd/Ctrl+S`. 4. Open the [Command Palette](https://athas.dev/docs/command-palette) with `Cmd/Ctrl+Shift+P` to discover actions. 5. Show the [terminal](https://athas.dev/docs/terminal) with `Cmd/Ctrl+J` and run your project's usual commands. `Cmd/Ctrl` means Command on macOS and Control on Windows/Linux. Shortcuts in these guides use the default Athas keymap; presets, custom bindings, and the focused pane can change them. ## Find the right guide | I want to… | Start here | | ----------------------------------- | ------------------------------------------------------------------------------------------------------------ | | Navigate and edit code | [Quick Open](https://athas.dev/docs/quick-open), [Editing](https://athas.dev/docs/editing), [Search](https://athas.dev/docs/search) | | Get completions, symbols and errors | [Language servers](https://athas.dev/docs/language-servers), [Diagnostics](https://athas.dev/docs/diagnostics), [Formatting](https://athas.dev/docs/formatting) | | Review and commit a change | [Git](https://athas.dev/docs/git-integration), [Diffs](https://athas.dev/docs/git-diff), [Worktrees](https://athas.dev/docs/git-worktrees) | | Use an AI coding agent | [AI overview](https://athas.dev/docs/ai), [Athas Agent](https://athas.dev/docs/athas-agent), [External agents](https://athas.dev/docs/external-agents) | | Work across machines | [Remote connections](https://athas.dev/docs/remote), [WSL](https://athas.dev/docs/wsl) | | Inspect data | [Database viewer](https://athas.dev/docs/database-viewer) | | Change my setup | [Settings](https://athas.dev/docs/settings), [Themes](https://athas.dev/docs/themes), [Keymaps](https://athas.dev/docs/keymaps), [Vim](https://athas.dev/docs/vim) | | Share work | [Share to Web](https://athas.dev/docs/sharing), [Collaboration](https://athas.dev/docs/collaboration) | | Fix a problem | [Troubleshooting](https://athas.dev/docs/troubleshooting), [Updates](https://athas.dev/docs/updates) | ## Accounts and online features Sign in for account-backed features such as hosted AI, settings sync, sharing and dashboard integrations. Requirements differ by feature: each guide states its account and plan limits. See [pricing](https://athas.dev/pricing) for current plans and [Enterprise controls](https://athas.dev/docs/enterprise) for managed workspaces. ## Use these docs Search with `Cmd/Ctrl+K` to find pages and sections, including commands and troubleshooting. Use **Copy page** for clean Markdown, **Markdown** for a machine-readable page, or **Suggest an edit** to propose a correction. The on-page contents links jump to a specific section. For assistants and automation, start with [Documentation for LLMs](https://athas.dev/docs/for-llms). For privacy questions, read [Telemetry](https://athas.dev/docs/telemetry) and [Security](https://athas.dev/security). To contribute to the editor, follow [Contributing](https://athas.dev/docs/contributing). --- # Installation Source: https://athas.dev/docs/installation Install Athas on macOS, Windows or Linux, choose a package, and safely uninstall it. Choose the build for your operating system and CPU architecture from [Download Athas](https://athas.dev/download). Use stable releases for everyday work; see [Updates](https://athas.dev/docs/updates) for upgrades. ## Quick Install ### macOS / Linux ```bash curl -fsSL https://athas.dev/install.sh | sh ``` If you prefer `wget`: ```bash wget -qO- https://athas.dev/install.sh | sh ``` ### Windows ```powershell powershell -ExecutionPolicy ByPass -c "irm https://athas.dev/install.ps1 | iex" ``` The install script detects your OS and architecture, downloads the latest stable release from GitHub by default, verifies the SHA256 checksum when available, and installs it. To install a specific release, pass its version: ```bash curl -fsSL https://athas.dev/install.sh | sh -s -- --version 0.15.1 ``` On macOS, the script installs Athas to `/Applications`. On Linux, it installs the app bundle to `~/.local/share/athas/athas.app` and links the executable at `~/.local/bin/athas`. On Linux, Athas uses the system WebKitGTK 4.1. The script checks for it and, if it is missing, prints the command to install it instead of installing an app that cannot start: | Distribution | Package | | -------------- | --------------------- | | Debian, Ubuntu | `libwebkit2gtk-4.1-0` | | Fedora | `webkit2gtk4.1` | | Arch Linux | `webkit2gtk-4.1` | | openSUSE | `libwebkit2gtk-4_1-0` | **Info:** You can inspect the script before running it: ```bash curl -fsSL https://athas.dev/install.sh | less ``` ## Package Managers ### Homebrew ```bash brew install --cask athas ``` ### Arch Linux (AUR) ```bash yay -S athas-bin ``` ### Nix ```bash nix run github:athasdev/athas ``` The Homebrew cask and the `athas-bin` AUR package are maintained by the community. WinGet and Scoop packages are on the way; until then use the PowerShell command above or the Windows installer. ## Manual Download Download the latest version from GitHub releases: **[Download from GitHub Releases](https://github.com/athasdev/athas/releases)** ### macOS 1. Download the `.dmg` file from [releases](https://github.com/athasdev/athas/releases) 2. Open the downloaded file 3. Drag Athas to your Applications folder 4. Open Athas from Applications ### Windows 1. Download the NSIS `.exe` or `.msi` installer from [releases](https://github.com/athasdev/athas/releases) 2. Run the installer 3. Follow the installation wizard 4. Launch Athas from the Start Menu ### Linux Download the package for your distribution and architecture (x64 or ARM64) from the [download page](https://athas.dev/download) or [releases](https://github.com/athasdev/athas/releases). The AppImage runs on most distributions without installing anything. If it does not start, install FUSE 2 (`libfuse2`): ```bash chmod +x Athas_*.AppImage ./Athas_*.AppImage ``` Debian and Ubuntu: ```bash sudo apt install ./Athas_*_amd64.deb ``` Fedora and other RPM-based distributions: ```bash sudo dnf install ./Athas-*.rpm ``` The Flatpak bundle fetches the GNOME runtime from Flathub on install. The integrated terminal opens your host shell, but language servers, formatters and other tools that only exist on the host are not visible inside the sandbox; use the AppImage, deb or rpm when you rely on them. ```bash flatpak install --user ./Athas_*_linux-*.flatpak flatpak run com.code.athas ``` The portable `.tar.gz` bundle needs no system-wide installation, but it uses the system WebKitGTK 4.1 (see the table above for the package name): ```bash tar -xzf Athas_*_linux-*.tar.gz ./athas.app/bin/athas ``` To make `athas` available from your shell: ```bash mkdir -p ~/.local/share/athas ~/.local/bin mv athas.app ~/.local/share/athas/athas.app ln -sf ~/.local/share/athas/athas.app/bin/athas ~/.local/bin/athas ``` ## Verify the install Open Athas, open a project folder, save a test file, and open the terminal. Install the shell command from **Settings > General > Terminal Command**, then run `athas --help` in a new shell. If the app will not launch, record the exact error and package format for [Troubleshooting](https://athas.dev/docs/troubleshooting). ## Uninstall Quit Athas before uninstalling. Removing user-data directories also removes local settings and history; export or back up anything you want to keep first. Removing only the application preserves its user data. Use the package manager that installed the app when possible. ### macOS ```bash rm -rf /Applications/Athas.app ``` Optional: permanently remove local settings/history and cache after backing them up: ```bash rm -rf ~/Library/Application\ Support/com.code.athas rm -rf ~/Library/Caches/com.code.athas ``` ### Windows Uninstall from **Settings > Apps > Installed apps** or run the uninstaller from the Start Menu. Optional: permanently remove remaining user data after backing it up: ```powershell Remove-Item -Recurse -Force "$env:APPDATA\com.code.athas" ``` ### Linux If installed by the quick install script: ```bash rm -f ~/.local/bin/athas rm -rf ~/.local/share/athas/athas.app rm -f ~/.local/share/applications/com.code.athas.desktop ``` If installed from a native package: ```bash sudo apt remove athas # or sudo dnf remove athas ``` If installed from the Flatpak bundle: ```bash flatpak uninstall --user com.code.athas ``` The AppImage is a single file; delete it to remove Athas. Optional: permanently remove application data after backing it up: ```bash rm -rf ~/.local/share/com.code.athas rm -rf ~/.config/com.code.athas ``` --- # Updates Source: https://athas.dev/docs/updates Update Athas with the built-in updater or your package manager, and recover from installation problems. Stable releases are the default for everyday work. Read the release notes before updating. ## Check for updates Open **Settings > General** to check for a new desktop release. Save your work before applying an update and restarting. Review the [changelog](https://athas.dev/docs/changelog) for changes relevant to your platform. If you installed Athas through Homebrew, the community AUR package, Nix or a Linux package manager, you can also update through that same manager. Follow the [installation guide](https://athas.dev/docs/installation) for manual packages. ## Update failures Check network access and available disk space. If the updater cannot finish, download the correct installer from [Download Athas](https://athas.dev/download) and reinstall the application. Reinstalling the app and deleting your user data are separate actions; back up settings before intentionally resetting data. Include the current version, offered version, platform, CPU architecture and error when reporting an update problem. See [Troubleshooting](https://athas.dev/docs/troubleshooting). --- # Troubleshooting Source: https://athas.dev/docs/troubleshooting Resolve startup, language tooling, terminal, AI, and connection problems with actionable checks. Start with the symptom, the affected workspace, and the exact error. Change one thing at a time so you can tell what fixed the problem. ## App will not start Check that the downloaded artifact matches your OS and CPU architecture. Try a current stable installer from [the download page](https://athas.dev/download). On Linux, the portable bundle uses system WebKitGTK 4.1; a missing shared-library error identifies a runtime dependency to install through your distribution. Do not remove settings or bypass OS security checks as your first step. Report the exact launch error and install method. See [Installation](https://athas.dev/docs/installation) and [Updates](https://athas.dev/docs/updates). ## No symbols, completions or diagnostics Confirm the active project root, detected language and enabled integration. Install project requirements, inspect **LSP: Show Status**, then run **Language Server: Restart All Servers**. See [Language servers](https://athas.dev/docs/language-servers). ## Terminal will not launch Check the selected shell/profile in Settings and try running that shell outside Athas. Confirm its startup directory still exists. On Windows, confirm the selected WSL distribution is installed. If shell integration changes prompt behavior, turn it off temporarily to compare. See [Terminal](https://athas.dev/docs/terminal) and [WSL](https://athas.dev/docs/wsl). ## AI request fails Check the selected model and connection, network access, key validity and provider error. A hosted credit/cap error differs from a provider-key error. External agents authenticate through their own CLI. Custom endpoints need the exact model ID and a supported API. See [Providers and Models](https://athas.dev/docs/ai-providers), [External agents](https://athas.dev/docs/external-agents) and [MCP](https://athas.dev/docs/mcp). ## Command or panel is missing Search the command palette and confirm the feature is enabled in Settings. Some commands require an open file, a Git repository, an installed integration, or a particular plan. Inspect the current keymap rather than assuming a shortcut from another editor. ## Collect a useful report Run **Developer: Open Athas Log** from the command palette and inspect the relevant error. Use the bug-report action in General settings or [open an issue](https://github.com/athasdev/athas/issues). Include: - Athas version, OS version, CPU architecture and installation method. - What you expected, what happened, and repeatable steps. - The affected language, integration, shell or provider, when relevant. - A small sample project or screenshot and relevant log lines. Remove tokens, passwords, personal paths and private project contents before sharing a report. [Telemetry](https://athas.dev/docs/telemetry) explains what the app sends automatically. --- # Quick Open Source: https://athas.dev/docs/quick-open Open files by name with fuzzy search, recent files, previews, and keyboard navigation. Quick Open is the fastest way to navigate to any file in your project using fuzzy search. ## Open Quick Open - `Cmd+P` (macOS) / `Ctrl+P` (Windows/Linux) - `Cmd+K` (macOS) / `Ctrl+K` (Windows/Linux) ## Navigate Results - Type to filter files using fuzzy search - Use `Arrow Up` / `Arrow Down` to move through results - Press `Enter` to open the selected file - Press `Esc` or `Cmd+K` / `Ctrl+K` to close ## File Categories Results are grouped and prioritized in this order: 1. **Open** — files currently open in editor tabs (marked with a blue badge) 2. **Recent** — recently visited files ordered by frecency (marked with a clock icon) 3. **Other** — remaining project files sorted alphabetically ## Fuzzy Search Quick Open uses fuzzy matching so you don't need to type exact file names: - Type `utl` to match `utils.ts` - Type `appcss` to match `app/styles.css` - Short queries (1–2 characters) require a substring match for precision ## File Preview When **Quick Open Preview** is enabled (Settings > Appearance), a preview pane appears on the right side showing the content of the currently selected file. - Hover over a file to preview it - Navigate with keyboard to update the preview automatically - Toggle the setting to hide the preview and get a narrower layout **Tip:** Quick Open caches the project file index after the first open, so subsequent opens are instant. The index refreshes automatically when you switch projects. ## Ignored Files Quick Open automatically excludes files and directories that are not useful for navigation: - Build output: `dist/`, `build/`, `out/`, `.next/` - Dependencies: `node_modules/`, `target/` - Lock files: `bun.lockb`, `yarn.lock`, `Cargo.lock` - Generated files: `*.map`, `*.min.js`, `*.min.css` - VCS: `.git/` ## If a file is missing Confirm the active project, clear the query and check ignored files. Quick Open matches names, not file contents. Use [Search](https://athas.dev/docs/search) for text inside files and [Editing](https://athas.dev/docs/editing) for tab and save actions. --- # Editing code Source: https://athas.dev/docs/editing Save files, use multiple cursors, fold code, and preview Markdown in Athas. Open a file from the file tree or [Quick Open](https://athas.dev/docs/quick-open). Changes stay in the editor buffer until you save, unless you enable Auto Save in Settings. ## Save and recover tabs | Action | Default shortcut | | ----------------- | ------------------ | | Save current file | `Cmd/Ctrl+S` | | Save as | `Cmd/Ctrl+Shift+S` | | Save all files | `Cmd/Ctrl+Alt+S` | | New tab | `Cmd/Ctrl+N` | | Close current tab | `Cmd/Ctrl+W` | | Reopen closed tab | `Cmd/Ctrl+Shift+T` | When sharing or reviewing work, distinguish an unsaved buffer from the file on disk. [Share Buffer to Web](https://athas.dev/docs/sharing) can include unsaved text; your build and Git tools read saved files. ## Multiple cursors and selections Select a word and use **Add Selection To Next Find Match** (`Cmd/Ctrl+D`) to extend the edit to another occurrence. The command palette also offers **Select All Occurrences of Find Match**, **Add Cursor Above**, **Add Cursor Below**, and **Remove Secondary Cursors**. Use multiple cursors for repeated local edits. For a project-wide rename or replacement, inspect [Search](https://athas.dev/docs/search) results and use language tooling where available. ## Lines, comments and folding The command palette includes **Duplicate Line**, **Delete Line**, **Move Line Up/Down**, **Toggle Comment**, **Fold All**, **Unfold All**, and folding by level. Supported comment syntax and fold ranges depend on the active language. ## Markdown preview Open a Markdown file and use **Preview Markdown** from the command palette. The preview follows the current buffer, so you can inspect unsaved changes. Vim users can run `:preview`. ## Configure the editor Use Settings for font, tab size, wrapping, line numbers, Auto Save, minimap and Vim mode. [Formatting](https://athas.dev/docs/formatting) is separate from saving; enable format on save if you want both. See [Keymaps](https://athas.dev/docs/keymaps) to inspect the binding for each action in your selected preset. --- # Search and replace Source: https://athas.dev/docs/search Find text in a file or across your project, filter results, and review replacements. Use Quick Open to find a **file name** and Search to find **text inside files**. ## Search the current file 1. Focus an editor and press `Cmd/Ctrl+F`. 2. Enter text and move between matches using the search controls. 3. Enable match case, whole word, or regular expression matching when needed. 4. Open replace with `Ctrl+H` while the editor is focused, or find **Find and Replace** in the command palette. 5. Review the matches before replacing one or all occurrences. ## Search your project Open **Search: Global Search** from the command palette or press `Cmd/Ctrl+Shift+F`. Enter the query, expand a file's matches, and click a result to open its file at that position. Use include and exclude filters to narrow the search to relevant paths. For example, search for `TODO` and include `src/**` to inspect source files without reading all of your build output. Use literal text first; turn on regular expressions only when you need a pattern. Project search is also available through `Cmd/Ctrl+Shift+H`. The search surfaces show their current scope and filters; check those before applying a replacement. ## Replace across files Open the replacement controls, enter the replacement, and inspect the matching files. Start with a single replacement to confirm the result before replacing all. Review the resulting [Git diff](https://athas.dev/docs/git-diff), especially for generated files or large changes. ## Missing results - Confirm that the intended project is active and that the file is saved on disk. - Clear include/exclude filters and check match-case and regex switches. - If the Search feature is hidden, enable it in **Settings > Features**. - For files in Linux on Windows, open the [WSL workspace](https://athas.dev/docs/wsl) rather than searching a different Windows folder. For file navigation, use [Quick Open](https://athas.dev/docs/quick-open). For syntax and symbol navigation, see [Language servers](https://athas.dev/docs/language-servers) and [Outline](https://athas.dev/docs/outline). --- # Command Palette Source: https://athas.dev/docs/command-palette Find available Athas commands, run actions from the keyboard, and discover your current shortcuts. The Command Palette is the fastest way to access actions without leaving the keyboard. ## Open the Palette - `Cmd/Ctrl+Shift+P` ## Search and Run - Type to filter by command name, description, or category - Use arrow keys to navigate results - Press `Enter` to run the selected command - Press `Esc` to close **Info:** Enable **Persistent Commands** in **Settings > Features** to keep recently used commands at the top. ## Examples - View: Show Terminal - Preferences: Open Settings - View: Find - Git: Stage All Changes ## Missing or unavailable commands Commands follow the current context: formatting requires an editor, Git actions require a repository, and some online actions require a signed-in account or a plan. Check **Settings > Features** when an entire surface is hidden. The shortcut shown in the palette follows your current keymap. See [Keymaps](https://athas.dev/docs/keymaps) for bindings and [Troubleshooting](https://athas.dev/docs/troubleshooting) for disabled features. --- # Language servers Source: https://athas.dev/docs/language-servers Set up completions, diagnostics, symbols, and navigation with language integrations. Syntax colors and language intelligence are separate. Tree-sitter provides [syntax highlighting](https://athas.dev/docs/syntax-highlighting); a language server can provide completions, diagnostics, hover information, definitions and symbols. ## Set up a language 1. Open the project root, including its build files and dependency manifests. 2. Open **Integrations**, find the language, and read its installation requirements. 3. Install or enable its language tooling and any required runtime. 4. Open a source file and wait for the language server to initialize. 5. Use **LSP: Show Status** in the command palette to inspect active workspaces and errors. Different integrations provide different capabilities. Installing a grammar does not guarantee that a language server, formatter or linter is available. ## Use language intelligence - Trigger suggestions and parameter hints from the editor or command palette. - Use hover information and definition/reference actions where supported by the server. - Open [Outline](https://athas.dev/docs/outline) for file symbols. - Open [Diagnostics](https://athas.dev/docs/diagnostics) for errors and available quick fixes. - Use [Formatting](https://athas.dev/docs/formatting) when the language integration provides a formatter. ## Restart or stop servers Run **Language Server: Restart All Servers** after changing the environment or fixing a failed server installation. **Language Server: Stop All Servers** stops active servers. For Java projects, **Java: Refresh Project** and **Java: Organize Imports** are also available. ## When intelligence is missing Check the language selected for the file, the integration's installed/enabled state, its required runtime and the project root. Install your project's dependencies using its normal package manager. Then inspect **LSP: Show Status** and [the Athas log](https://athas.dev/docs/troubleshooting#collect-a-useful-report). A server can be running without supporting every action. Report the language, integration, server error and a small reproduction when asking for help. --- # Outline Source: https://athas.dev/docs/outline Navigate symbols in the active file from the sidebar or Command Palette. Outline shows the symbols reported by the active file's language tooling. ## Open Outline You can open Outline from any of these places: - Footer Outline button - Command Palette: **View: Show Outline** - Command Palette: **Go to Symbol in Editor** - `Cmd/Ctrl+Shift+O` If you do not use Outline, you can disable the feature in **Settings > Features**. ## Navigate Symbols The sidebar follows the active editor buffer and lists symbols such as classes, functions, methods, properties, variables, and types. - Click a symbol to jump to its source location - Use arrow keys to move through the list - Press `Enter` to open the focused symbol - Press `/` or `Cmd/Ctrl+F` to search within the outline - Use left and right arrow keys to collapse or expand nested symbols ## Filter Symbols Use the filter button in the Outline header to focus the list. Available filters include: - Types - Functions - Properties - Variables - Other symbols **Tip:** Search keeps matching parent symbols visible, so nested matches still make sense in context. ## Context Menu Right-click any Outline item to open its context menu. Available actions include: - Go to Symbol - Copy Name - Copy Location - Collapse or expand the selected symbol - Collapse All - Expand All You can also open the same menu from the keyboard with the context menu key or `Shift+F10`. ## Command Palette Outline The Command Palette outline is optimized for quick symbol jumps. Use **Go to Symbol in Editor** when you want to search and jump without opening the sidebar. Use the sidebar when you want a persistent view of the current file's structure. ## No symbols appear Open a supported source file and confirm its language integration is installed and enabled. Outline depends on symbols from [language tooling](https://athas.dev/docs/language-servers); syntax colors alone do not imply symbol support. --- # Diagnostics Source: https://athas.dev/docs/diagnostics Inspect problems, jump to source, apply quick fixes, and filter diagnostics in the bottom pane. Athas shows diagnostics in a dedicated bottom-pane Problems view. ## Open Diagnostics You can open the diagnostics pane from any of these entry points: - The diagnostics indicator in the footer - `Cmd/Ctrl+Shift+J` - Command Palette: **View: Show Diagnostics** If you do not use diagnostics, you can disable the surface entirely in **Settings > Features**. **Info:** The default shortcut is `Cmd/Ctrl+Shift+J`. If you switch to the VS Code keybinding preset, diagnostics move to `Cmd/Ctrl+Shift+M`. ## What You See The pane summarizes all current problems and keeps a live count in the footer. - Errors, warnings, and info diagnostics are shown together - The footer badge turns into a warning-colored count when problems exist - Clicking a problem jumps to its file and position - Editor gutter markers reflect the highest-severity problem on each line ## Search, Filter, and Group Athas lets you narrow the list without leaving the pane: - Search by message, source, code, file path, or line and column - Filter by severity - Filter to only the current file - Filter by diagnostic source from the context menu - Group by file, severity, or not at all - Sort by severity, file, or position ## Quick Fixes and Actions Right-click any problem to open its action menu. Available actions include: - Quick fixes exposed by the active language tooling - Go to Problem - Copy Message - Copy Location - Copy Full Details - Toggle wrapped messages ## Pane Controls The diagnostics pane supports the same bottom-pane workflow as terminal and references: - Resize it vertically from the top edge - Open it full screen - Switch between full-width and editor-width modes from the header context menu **Tip:** Diagnostics preferences such as grouping, sorting, current-file filtering, and message wrapping are remembered locally. ## No problems appear Confirm the relevant language server or linter is running. A clean list can mean either no reported problems or tooling that has not initialized. Check [Language servers](https://athas.dev/docs/language-servers) before treating an empty list as validation. --- # Formatting and linting Source: https://athas.dev/docs/formatting Format a file or selection, enable format on save, and diagnose missing formatters. Formatting rewrites code layout. Linting reports problems and may offer fixes. Each depends on your language tooling and project configuration. ## Format a file or selection 1. Open the source file and confirm its detected language. 2. Install or enable the relevant [language integration](https://athas.dev/docs/language-servers). 3. Run **Format Document** from the command palette (`Shift+Alt+F` in the default keymap). 4. For a smaller change, select code and run **Format Selection**. 5. Review the result and save the file. A formatter may support whole documents without supporting selected ranges. ## Format and lint on save Enable **Format on Save** and **Lint on Save** in Settings. Choose the formatter your project expects when a choice is available. Keep the project's formatter configuration in version control so teammates and CI use the same rules. If Auto Save is enabled, consider how often save-time tooling will run before turning on both. ## Troubleshoot formatting - Confirm the integration supplies a formatter for this language. - Check the required executable or runtime is installed. - Inspect project configuration for syntax errors or excluded paths. - Try **Format Document** manually and read any error before relying on save-time formatting. - Restart the [language server](https://athas.dev/docs/language-servers) if the tool's environment changed. Use [Diagnostics](https://athas.dev/docs/diagnostics) to inspect lint errors and quick fixes, and [Diff Viewer](https://athas.dev/docs/git-diff) to review formatting changes before committing. --- # Syntax Highlighting Source: https://athas.dev/docs/syntax-highlighting Understand built-in Tree-sitter syntax highlighting, language integrations, and language intelligence. Athas uses Tree-sitter for syntax highlighting. ## Built In (Default) These languages are bundled in Athas and work without installing an integration: - Bash - C - C# - C++ - CSS - Dart - Elisp - Elixir - Go - HTML - Java - JavaScript - JSON - Kotlin - Lua - Markdown - Objective-C - OCaml - PHP - Python - ReScript - Ruby - Rust - Scala - Solidity - Swift - SystemRDL - TLA+ - TOML - TSX - TypeScript - Vue - YAML - Zig ## Extension Fallback These languages currently rely on integration-hosted grammar assets: - Elm - QL ## Colors versus language intelligence Highlighting colors parsed syntax. For completions, hover information, symbols and errors, configure a [language server](https://athas.dev/docs/language-servers). Check the detected file language and enabled integration when a file is uncolored; the [catalog](https://athas.dev/integrations) lists available tooling. --- # Workspaces Source: https://athas.dev/docs/workspaces Open project folders, switch between projects, and keep worktrees or remote workspaces separate. A workspace is the set of projects you have open in a single Athas window. ## Create a Workspace - Open Athas and click the **+** button to add your first project - Drag and drop a folder onto the editor window ## Manage Workspace Projects - Add a project with the **+** button or by dragging a folder - Switch projects by clicking their tabs - Reorder tabs by dragging them - Close a project using the tab’s close button (X) Project tabs are restored when you restart Athas. Git worktrees open through the same workspace flow. See [Worktrees](https://athas.dev/docs/git-worktrees) for opening separate branch checkouts in the current window or a new Athas window. On Windows, WSL projects also open through the project picker. See [WSL](https://athas.dev/docs/wsl) for opening Linux distribution paths such as `/home/me/project`. ## Choose the correct project Commands, search and Git actions depend on the active project. Check its path before running a build or starting an agent. Use [Remote connections](https://athas.dev/docs/remote) for SSH/SFTP, [WSL](https://athas.dev/docs/wsl) for Linux projects on Windows, and the [CLI](https://athas.dev/docs/cli) to open a specific folder. --- # Terminal Source: https://athas.dev/docs/terminal Integrated terminal with shell integration, split panes, and multiple shells Athas includes a built-in terminal so you can run commands without leaving the editor. ## Features - **Multiple Terminals**: Create as many terminal tabs as you need and pin the important ones - **Split Panes**: Split any terminal right or down, nest splits, and drag the dividers - **Shell Selection**: Choose bash, zsh, fish, nushell, PowerShell, or a custom profile - **Shell Integration**: Prompt marks, exit codes, and working-directory tracking for zsh, bash, fish, PowerShell, and Git Bash - **Clickable Links**: URLs, file paths with line numbers, and OSC 8 hyperlinks open with `Cmd/Ctrl+Click` - **Command Notifications**: Get told when a long command finishes in a terminal you are not looking at - **Terminal Persistence**: Terminals and their split layouts restore across app restarts - **Search**: Use `Cmd/Ctrl+F` to search terminal output On Windows, WSL distributions appear as terminal shells. Terminals created from WSL workspaces start in the matching Linux distribution and working directory. See [WSL](https://athas.dev/docs/wsl). ## Shell Integration When shell integration is enabled (the default), Athas injects a small script into supported shells at launch. Nothing is written to your dotfiles. - Each prompt gets a mark in the gutter that turns green or red once the command finishes - `Cmd/Ctrl+Up` and `Cmd/Ctrl+Down` jump between previous and next commands - **Copy Last Command Output** (`Cmd/Ctrl+Shift+C`) copies exactly what the previous command printed - The tab title follows the shell's working directory - Programs that report progress (for example `winget` or a build script using OSC 9;4) show a progress indicator in the tab Shell integration can be turned off under **Settings → Terminal → Launch**. ## Split Panes - Split the focused terminal with `Cmd/Ctrl+D` (right) or `Cmd/Ctrl+Shift+D` (down) - Split any tab from its context menu, or drag a tab onto the edge of a terminal pane - Drag the divider to resize; double-click it to make the panes equal again - `Cmd/Ctrl+Alt+Left` and `Cmd/Ctrl+Alt+Right` move focus between panes - **Unsplit** from the context menu or command palette moves a pane back into its own tab - Closing a pane collapses the split and focuses its neighbour ## Links Hover a link to see where it goes, then `Cmd+Click` (macOS) or `Ctrl+Click` (Windows, Linux) to open it. Web and mail links open in your browser. File paths, including `path:line:column` forms printed by compilers and test runners, open in the editor at that position. Tools that emit OSC 8 hyperlinks, such as `ls --hyperlink` and ripgrep, work the same way. ## Command Notifications If a command runs for at least ten seconds and finishes while its terminal is hidden, not the active tab, or the window is in the background, Athas shows a toast with a **Show** action, adds an entry to the notification center, and sends a native notification when the app is not focused. Inactive tabs also show a green or red dot until you look at them. Turn this off under **Settings → Terminal → Launch → Command Notifications**. ## Colors Every builtin theme ships a full 16-color ANSI palette, so `ls`, `git`, and test runners look as their authors intended. Custom themes can define `terminal-black` through `terminal-bright-white`. The **Minimum Contrast** setting lifts colors that would be hard to read against the background without changing the theme itself. ## Context Menu Right-click a terminal tab for: - Pin/Unpin Terminal - Split Right, Split Down, and Unsplit - Duplicate Terminal - Clear Terminal - Rename Terminal - Export Output - Close Terminal, Close Others, Close All, Close to the Right ## Keyboard Shortcuts **Terminal Management** - `Cmd/Ctrl+N` - New terminal while the terminal is focused - `Cmd/Ctrl+W` - Close current terminal or pane - `Cmd/Ctrl+D` - Split right - `Cmd/Ctrl+Shift+D` - Split down - `Cmd/Ctrl+Alt+Left` / `Cmd/Ctrl+Alt+Right` - Focus previous / next pane - `Ctrl+PageUp` / `Ctrl+PageDown` - Previous / next terminal - `Cmd/Ctrl+1-9` - Switch to terminal by number **Terminal Operations** - `Cmd/Ctrl+F` - Search in terminal - `Cmd/Ctrl+K` - Clear terminal - `Cmd/Ctrl+Shift+A` - Select all - `Cmd/Ctrl+Shift+C` - Copy last command output - `Cmd/Ctrl+Up` / `Cmd/Ctrl+Down` - Previous / next command - `Cmd/Ctrl++` - Increase font size - `Cmd/Ctrl+-` - Decrease font size Every shortcut can be changed under **Settings → Keyboard**. --- # Browser Source: https://athas.dev/docs/browser Open web pages and local development servers in editor tabs Athas can show web pages in tabs next to your code, so a local development server, its docs, or an issue tracker stays one tab away while you work. ## Opening a Browser Tab - Choose **New Browser Tab** from the **+** menu of any tab bar - Run **Browser: New Browser Tab** or **Browser: Open URL...** from the command palette Type an address or a search into the address bar and press `Enter`. Addresses without a scheme work as you would expect: `localhost:5173`, `127.0.0.1:8080/health` and `:3000` open over HTTP, `athas.dev/docs` opens over HTTPS, and anything else searches the web. Links a page opens in a new window open as a new browser tab. Mail and phone links open in your default apps. Downloads are saved to your Downloads folder, and a toast lets you reveal the file when it finishes. ## Tabs and Panes Browser tabs behave like other tabs: split them, move them between panes, pin them, and reorder them. A page keeps running while its tab is in the background, so switching back never reloads it or loses what you typed. Open browser tabs, their addresses and zoom levels are restored when you reopen the workspace. ## Shortcuts While a page has focus, it receives its own keyboard shortcuts, except the ones that move around Athas: the command palette, quick open, new, close and reopen tab, tab switching, and toggling the sidebar or terminal keep working. Rebinding those commands in [keymaps](https://athas.dev/docs/keymaps) changes them for browser tabs too. | Action | macOS | Windows, Linux | | --------------------- | --------------------------- | ------------------------------ | | Focus the address bar | `Cmd+L` | `Ctrl+L` | | Reload | `Cmd+R` | `Ctrl+R` | | Back / Forward | `Cmd+[` / `Cmd+]` | `Ctrl+[` / `Ctrl+]` | | Zoom in / out / reset | `Cmd+=` / `Cmd+-` / `Cmd+0` | `Ctrl+=` / `Ctrl+-` / `Ctrl+0` | | Page developer tools | `Cmd+Alt+I` | `Ctrl+Alt+I` | ## Privacy and Security Pages run in the system web view (WebKit on macOS and Linux, WebView2 on Windows) and keep their cookies and storage in a browser profile separate from Athas itself. **Clear Browsing Data** in the page menu removes that profile's cookies, storage and cache; on macOS it needs macOS 14 or later. Pages cannot call into Athas. The only thing a page can tell Athas is which tab has focus, its title, icon and history position, and which of the shortcuts above was pressed. Pages can never load the Athas interface itself or local files. Developer tools for pages are available in development builds of Athas. ## Local development servers Start the server in a [terminal](https://athas.dev/docs/terminal) before opening its localhost address. A refused connection usually means the process is stopped or listening on a different port. A browser tab is local to your device. --- # CLI Source: https://athas.dev/docs/cli Open files, viewers, terminals, and remote workspaces from the command line Athas ships with a small CLI so you can jump into the right workspace or tool without leaving your shell. ## Install the command Install the `athas` command from **Settings > General > Terminal Command** inside the app. Once installed, make sure the generated bin directory is in your `PATH`. ## Usage ```bash athas [--new-window | --reuse-window] [paths...] athas open [--new-window | --reuse-window] athas window athas settings athas extensions athas pr [--cwd ] athas issue [--cwd ] athas action [--cwd ] athas web athas terminal [--cwd ] [--reuse-window] [--] [command...] athas remote [name] ``` ## Open files and folders These commands open files or folders in Athas: ```bash athas index.html athas src/main.rs:120 athas . athas open README.md docs/architecture.md ``` Athas automatically chooses the right surface for many file types: - Images open in the image viewer - PDF files open in the PDF viewer - `.db`, `.sqlite`, `.sqlite3`, and `.duckdb` files open in the database viewer - Markdown, HTML, and CSV files can be opened and then previewed inside Athas ## Open the web viewer Use the built-in web viewer without opening the app first: ```bash athas web https://athas.dev/docs ``` ## Open a terminal tab Open a blank terminal in the current working directory: ```bash athas terminal ``` Open a terminal and run a command immediately: ```bash athas terminal -- bun test ``` The terminal uses the directory where you ran the command as its working directory. ## Open a remote workspace If you already saved a remote connection in Athas, you can reopen it directly from the shell: ```bash athas remote conn-123 athas remote conn-123 "My Server" ``` Use the saved connection id from Athas' remote connections UI. ## Help Print the built-in usage text: ```bash athas --help ``` ## Windows and standalone tools Use `athas --new-window .` to open a project in a separate window, or `athas window` for an empty window. `athas settings` and `athas extensions` open their corresponding surfaces. Repository commands such as `athas pr 42 --cwd /path/to/repo` use the specified repository context. Use `--reuse-window` when you want a supported target in the existing workspace. Put terminal commands after `--` so their flags are passed to the command rather than the Athas launcher. ## Command not found Install the command from Settings or **CLI: Install Terminal Command** in the command palette, then open a new shell and check `athas --help`. Confirm the generated bin directory is on `PATH`. The CLI opens existing paths: check the path and permissions if an open request fails. See [Workspaces](https://athas.dev/docs/workspaces), [Remote connections](https://athas.dev/docs/remote), and [Browser](https://athas.dev/docs/browser). ## Related workflows Use [Terminal](https://athas.dev/docs/terminal) to manage the opened session and [GitHub Integration](https://athas.dev/docs/github-integration) for repository account access. --- # Remote connections Source: https://athas.dev/docs/remote Connect to SSH or SFTP hosts, verify host identity, and reopen saved connections. Athas can open remote files through saved SSH or SFTP connections. You need a reachable server, an account on that server, and authentication accepted by it. ## Create a connection Enable Remote in Settings if its surface is hidden, then open the Remote sidebar and add a connection. Enter a name, connection type, host or SSH config alias, port and username. Configure password or private-key authentication as appropriate. Test the connection before opening the remote workspace. Use the server's configured port; `22` is the usual SSH default. A VPN, firewall or jump-host setup can affect reachability independently of your credentials. ## Verify the host Check the presented host fingerprint against a trusted source before accepting a new host. A changed host key can mean the server was rebuilt or that you are reaching a different machine. Investigate the change rather than repeatedly accepting it. ## Work with remote files Browse and edit files within the connected account's permissions. Saving changes writes to the remote location; it is not a local copy. Keep backups or version control on the server when editing important files. ## Reopen from the CLI After saving a connection, use its ID with the [Athas CLI](https://athas.dev/docs/cli): ```bash athas remote athas remote "My server" ``` For Linux projects on the same Windows machine, [WSL](https://athas.dev/docs/wsl) may be the appropriate workspace instead. --- # WSL Source: https://athas.dev/docs/wsl Open and edit Windows Subsystem for Linux projects Athas supports Windows Subsystem for Linux projects on Windows. WSL projects use Linux paths inside the selected distribution, while Athas keeps the workspace identity as a `wsl://` path such as `wsl://Ubuntu/home/me/project`. ## Requirements - Windows with WSL installed - At least one installed WSL distribution - Project files stored inside the distribution filesystem, such as `/home/me/project` Athas discovers distributions with `wsl --list --verbose`, the same WSL command documented in [Microsoft's WSL command reference](https://learn.microsoft.com/en-us/windows/wsl/basic-commands). Microsoft also recommends storing Linux project files inside the Linux filesystem instead of editing them from `/mnt/c` when working with Linux tools; see [Working across Windows and Linux file systems](https://learn.microsoft.com/en-us/windows/wsl/filesystems). ## Open a WSL Project 1. Open the project picker 2. Select a WSL distribution 3. Enter the Linux project path, such as `/home/me/project` 4. Open the project The project opens as a normal Athas workspace. Recent WSL projects and project tabs restore across restarts. ## Files WSL workspaces support the normal file actions: - Browse folders and files - Open and save files - Create files and folders - Rename, move, duplicate, and delete paths - Follow symlinks inside the same distribution - Reveal files in Windows Explorer through the WSL UNC path Athas keeps WSL paths inside the selected distribution. Moving files between a WSL distribution and a local Windows folder is not treated as a rename. ## Search Quick Open, file-tree search, and content search work against the WSL project through Athas' WSL file provider. ## Terminal When a terminal is created from a WSL workspace, Athas starts `wsl.exe` with the matching distribution and Linux working directory. WSL distributions also appear as selectable terminal shells on Windows. ## Git Git repositories inside WSL workspaces work with Athas' Git views: - Repository discovery - Status - Diffs - Staging and unstaging - Commits - Branches, tags, stashes, blame, and history Git paths are resolved through the WSL filesystem bridge while the editor keeps display paths in `wsl://` form. ## Paths Athas displays WSL project paths as: ```text wsl:/// ``` Examples: ```text wsl://Ubuntu/home/me/project wsl://Debian/etc/nginx ``` Use Linux paths when opening projects or entering terminal working directories. Use Windows paths only for local Windows projects. ## Troubleshoot a distribution Confirm the distribution starts from Windows with `wsl -d ` and that the Linux path exists for your user. Keep Windows and Linux paths distinct. See [Terminal](https://athas.dev/docs/terminal) for shell profiles and [Troubleshooting](https://athas.dev/docs/troubleshooting) for reports. --- # Git Integration Source: https://athas.dev/docs/git-integration Review file changes, stage and commit work, and navigate Git branches, history, and worktrees. Athas includes powerful Git integration. ## Features - **Source Control Panel**: View changed files, stage, and commit - **Branch Management**: Create, switch, and merge branches - **Worktree Management**: Open separate checkouts as current-window or new-window workspaces - **Commit History**: Browse commit log with diffs - **Inline Blame**: See who changed each line - **Diff Viewer**: Side-by-side and inline diff views - **Stash Management**: Save and restore work in progress ## Getting Started 1. Open a folder that is a Git repository 2. Click the Git icon in the sidebar 3. View changed files, stage changes, and commit ## Source Control Panel - **Staged Changes**: Files ready to commit - **Changes**: Modified files not yet staged - **Untracked**: New files not tracked by Git Click the `+` icon to stage files, or use the checkmark to commit. GitHub account features are separate from local Git operations. See [GitHub Integration](https://athas.dev/docs/github-integration) for dashboard sync, account access, and token storage details. Use [Worktrees](https://athas.dev/docs/git-worktrees) when you want multiple branches checked out at the same time with separate workspace, terminal, and Git status state. On Windows, Git repositories inside WSL workspaces are supported through Athas' WSL path bridge. See [WSL](https://athas.dev/docs/wsl). ## Keyboard Shortcuts - `Cmd/Ctrl+Shift+G`: Open Source Control panel - `Cmd/Ctrl+Enter`: Commit staged changes ## Review before committing Save edited files before inspecting status. Stage only the changes you intend to include, review the staged [diff](https://athas.dev/docs/git-diff), and then commit. Local commits and remote pushes are separate operations. Check the active project and branch before publishing work. --- # GitHub Integration Source: https://athas.dev/docs/github-integration Connect GitHub for dashboard inbox sync and desktop repository views. Athas can connect your GitHub account so repository activity appears in the web dashboard and in the desktop GitHub sidebar. ## What It Enables - **Dashboard inbox**: Sync GitHub Issues, Pull Requests, Discussions, Actions, Releases, and Notifications into your Athas inbox - **GitHub views in desktop**: Show pull requests, issues, and workflow activity for the current repository - **Connected account status**: Display the linked GitHub account and granted OAuth scopes in Dashboard > Integrations ## Permissions Athas requests `repo read:user` when you connect GitHub from Dashboard > Integrations. The `read:user` permission is used to identify the connected GitHub account. The `repo` permission allows Athas to read repository activity, including private repositories you can access. ## Token Storage When GitHub returns an OAuth access token, Athas encrypts it before storing it on the Athas server. The web dashboard uses that token server-side when it syncs GitHub activity into your inbox. The desktop app does not use your web browser cookie to call GitHub. It signs in to Athas with a desktop session token, fetches your connected GitHub token from Athas, and stores it locally in the OS keychain when available. GitHub API calls from the desktop app then use that GitHub token directly. Athas records an activity log entry when the desktop app syncs the GitHub token, but the token itself is never written to the activity log. ## Synced Data The dashboard sync stores inbox items derived from GitHub data, including titles, bodies, authors, labels, URLs, repository names, issue or pull request numbers, workflow status, release metadata, and notification reasons. ## Disconnecting Use Dashboard > Integrations > GitHub > Disconnect to remove the stored GitHub integration from Athas. You can also revoke the OAuth grant from GitHub's application settings. After disconnecting, the dashboard can no longer sync new GitHub activity. The desktop app will remove its local GitHub token the next time it checks the connected account and sees that GitHub is not connected. ## GitHub access versus Git transport The connected GitHub account supplies API features. It does not automatically configure every SSH key or Git credential helper used for clone, fetch and push. If a Git operation fails, check its own transport credentials as well as the [connected dashboard account](https://athas.dev/docs/dashboard-integrations). --- # Branches Source: https://athas.dev/docs/git-branches Create, switch, merge, and delete Git branches while protecting local changes. Athas provides a visual branch manager. ## Current Branch The current branch is displayed in the status bar. Click it to quickly switch branches. ## Creating Branches 1. Open the branch manager 2. Click "New Branch" 3. Enter the branch name 4. Choose whether to checkout immediately ## Switching Branches 1. Open the branch manager 2. Click on any branch to switch to it 3. Or use the status bar branch selector ## Merging Branches 1. Checkout the target branch (e.g., `main`) 2. Open the branch manager 3. Right-click the branch you want to merge 4. Select "Merge into current branch" ## Deleting Branches 1. Open the branch manager 2. Right-click the branch to delete 3. Select "Delete Branch" 4. Confirm the deletion Note: You cannot delete the currently checked out branch. ## Remote Branches Remote branches are shown under "Remote Branches". You can checkout, fetch, or delete them. ## Protect local changes Inspect status and save your work before switching, merging or deleting branches. Git may reject a switch that would overwrite changes. Commit or stash them deliberately, or use a separate [worktree](https://athas.dev/docs/git-worktrees). Review conflicts and the final [diff](https://athas.dev/docs/git-diff) after a merge. --- # Worktrees Source: https://athas.dev/docs/git-worktrees Open and manage Git worktrees as Athas workspaces Git worktrees let one repository have multiple checked-out branches in separate folders. Athas treats each worktree as a real workspace folder, so editor tabs, terminals, Git status, and window state follow the checkout you open. ## When to Use Worktrees - Keep a feature branch open while reviewing another branch - Run a long task in one checkout without disturbing your main project - Compare or test separate branches in separate Athas windows - Keep branch-specific terminals, buffers, and Git status isolated ## Open a Worktree 1. Open a Git repository in Athas. 2. Open the Git sidebar. 3. Switch to the **Worktrees** tab. 4. Click a worktree to open it in the current window. Opening a worktree uses the same folder-open flow as any other project. The selected worktree becomes the active workspace project, and the Git sidebar starts reading status from that path. ## Open in a New Window Right-click a worktree and choose **Open in New Window** to launch that checkout in a separate Athas window. Use this when you want each branch to keep its own window, terminals, and editor layout. ## Create a Worktree Use the **+** button in the Worktrees tab to add another checkout. - Enter the destination path for the new checkout - Optionally create a new branch for that worktree - After creation, Athas can open the new checkout as the active workspace The footer worktree switcher also supports searching existing worktrees and creating one from a new path. ## Remove and Prune Right-click a worktree to remove it. - **Remove** uses Git's normal safe removal path - **Force Remove** is separate and can discard uncommitted changes in that checkout - **Prune** appears only when Git reports prunable worktrees Athas keeps force removal behind an explicit menu item so ordinary cleanup does not accidentally discard local work. ## Related Pages - [Workspaces](https://athas.dev/docs/workspaces) - [Git Integration](https://athas.dev/docs/git-integration) - [Branches](https://athas.dev/docs/git-branches) ## Before removing a checkout Inspect that worktree’s Git status and running terminals before removing it. Commit or copy changes you need. Force removal can discard work; pruning stale Git records and deleting a live checkout are different operations. See [Git](https://athas.dev/docs/git-integration) for review and commits. --- # Diff Viewer Source: https://athas.dev/docs/git-diff Compare working-tree, staged, and historical changes with inline or side-by-side diffs. Athas includes a powerful diff viewer. ## Viewing Diffs ### From Source Control 1. Open the Source Control panel 2. Click on any changed file 3. The diff viewer opens showing changes ### From Commit History 1. Open the commit history 2. Click on any commit 3. Click on a file to view its diff ## Diff Modes ### Inline Diff Shows additions and deletions inline: - Green background for additions - Red background for deletions ### Side-by-Side Diff Shows old and new versions side by side: - Left pane: original - Right pane: modified ## Gutter Indicators In the editor, the gutter shows Git change indicators: - **Green bar**: Added lines - **Red bar**: Deleted lines - **Yellow bar**: Modified lines Click on these indicators to see the original content. ## Inline Blame Enable inline blame in **Settings > Git** or toggle with `Cmd/Ctrl+Shift+B`. ## What a diff proves A working-tree diff shows saved changes; a staged diff shows what the next commit includes. Compare the correct versions and check the active branch. A clean diff does not prove tests passed. Return to [Source Control](https://athas.dev/docs/git-integration) to stage and commit the reviewed change. --- # Database Viewer Source: https://athas.dev/docs/database-viewer Open SQLite and DuckDB files or connect to PostgreSQL, MySQL, MongoDB, and Redis from Athas. Athas includes a database viewer for local database files and saved network database connections. ## Open a Database Open a `.db`, `.sqlite`, `.sqlite3`, or `.duckdb` file from the file tree or from the `athas` CLI. Athas opens the file in a database tab automatically. For network databases, use **Database: Connect to Database** from the command palette or the Database settings tab. Saved connections are listed in **Settings > Database**. ## Supported Sources Athas currently supports: - [SQLite](https://athas.dev/docs/sqlite) - [DuckDB](https://athas.dev/docs/duckdb) - [PostgreSQL](https://athas.dev/docs/postgresql) - [MySQL](https://athas.dev/docs/mysql) - [MongoDB](https://athas.dev/docs/mongodb) - [Redis](https://athas.dev/docs/redis) SQLite is built in. DuckDB, PostgreSQL, MySQL, MongoDB, and Redis are database providers installed from **Integrations**. ## What you can do - Browse tables, views, collections, or keys depending on the database type - Inspect schemas and column details - Filter and search table data - Edit rows and cells where the provider supports writes - Run SQL queries for SQL databases - Copy or export result data when available ## Notes Local database files are opened directly and are not saved as connections. Saved connections are for network databases such as PostgreSQL, MySQL, MongoDB, and Redis. ## Connect and query deliberately Install the required provider, test a connection, and start with a read query. Use a read-only database account when browsing production data. Cell edits and SQL statements can change the original database; they are not isolated previews. Back up local files before experimenting. --- # SQLite Source: https://athas.dev/docs/sqlite Open and inspect SQLite database files directly in Athas. SQLite support is built into Athas for local database files. ## Open SQLite Files Open a `.db`, `.sqlite`, or `.sqlite3` file from the file tree or with the `athas` CLI. Athas opens the file in a database tab automatically. ## What You Can Do - Browse tables and views - Inspect columns and schema details - Filter and search table data - Edit rows and cells where supported - Run SQL queries - Copy or export result data when available ## Notes SQLite files are opened directly from disk. They are not saved as network database connections in **Settings > Database**. ## First query Start with a read query to confirm the connection and inspect the database: ```sql SELECT name FROM sqlite_master WHERE type = 'table'; ``` ## Troubleshooting Back up the database file before edits. If it is locked, check which other process has it open. See [Database viewer](https://athas.dev/docs/database-viewer) for shared connection and editing behavior. --- # DuckDB Source: https://athas.dev/docs/duckdb Open DuckDB files through the Athas database provider system. DuckDB support is available through the Athas database provider system. ## Open DuckDB Files Install the DuckDB provider from **Integrations**, then open a `.duckdb` or `.duck` file from the file tree or with the `athas` CLI. ## What You Can Do - Browse tables and views - Inspect columns and schema details - Run SQL queries - Filter and search result data - Copy or export result data when available ## Notes DuckDB is file-based like SQLite, but it is delivered as an installable database provider rather than as the built-in default provider. ## First query Start with a read query to confirm the connection and inspect the database: ```sql SELECT * FROM information_schema.tables LIMIT 20; ``` ## Troubleshooting Check the provider installation if the file opens as text. Work on a copy when testing writes. See [Database viewer](https://athas.dev/docs/database-viewer) for shared connection and editing behavior. --- # PostgreSQL Source: https://athas.dev/docs/postgresql Connect to PostgreSQL databases, inspect schemas, and run queries from Athas. PostgreSQL support is available through the PostgreSQL database provider. ## Connect to PostgreSQL Install the PostgreSQL provider from **Integrations**, then use **Database: Connect to Database** from the command palette or create a saved connection in **Settings > Database**. The default PostgreSQL port is `5432`. ## What You Can Do - Browse schemas, tables, and views - Inspect columns, indexes, and foreign keys where available - Filter and search table data - Run SQL queries - Edit rows and cells where supported - Copy or export result data when available ## Notes PostgreSQL connections are saved connections. They are managed from **Settings > Database** rather than opened from local files. ## First query Start with a read query to confirm the connection and inspect the database: ```sql SELECT current_database(), current_user; ``` ## Troubleshooting Check host, port, database name, user and server SSL requirements. Use a read-only account for inspection. See [Database viewer](https://athas.dev/docs/database-viewer) for shared connection and editing behavior. --- # MySQL Source: https://athas.dev/docs/mysql Connect to MySQL databases, browse tables, and run SQL queries from Athas. MySQL support is available through the MySQL database provider. ## Connect to MySQL Install the MySQL provider from **Integrations**, then use **Database: Connect to Database** from the command palette or create a saved connection in **Settings > Database**. The default MySQL port is `3306`. ## What You Can Do - Browse databases, tables, and views - Inspect columns and schema details - Filter and search table data - Run SQL queries - Edit rows and cells where supported - Copy or export result data when available ## Notes MySQL connections are saved connections. They are managed from **Settings > Database** rather than opened from local files. ## First query Start with a read query to confirm the connection and inspect the database: ```sql SELECT DATABASE(), CURRENT_USER(); ``` ## Troubleshooting Check host, port, database name, user and server TLS requirements. Use a read-only account for inspection. See [Database viewer](https://athas.dev/docs/database-viewer) for shared connection and editing behavior. --- # MongoDB Source: https://athas.dev/docs/mongodb Connect to MongoDB, browse collections, and inspect documents from Athas. MongoDB support is available through the MongoDB database provider. ## Connect to MongoDB Install the MongoDB provider from **Integrations**, then use **Database: Connect to Database** from the command palette or create a saved connection in **Settings > Database**. The default MongoDB port is `27017`. ## What You Can Do - Browse databases and collections - Inspect documents - Search and filter collection data where supported - Edit documents where supported - Copy result data when available ## Notes MongoDB is document-based, so the viewer uses collections and documents instead of SQL tables and rows. ## Troubleshooting Check the host, port, authentication database and user permissions. Opening the connection does not grant access to every collection. See [Database viewer](https://athas.dev/docs/database-viewer) for shared connection and editing behavior. --- # Redis Source: https://athas.dev/docs/redis Connect to Redis, scan keys, inspect values, and edit key data from Athas. Redis support is available through the Redis database provider. ## Connect to Redis Install the Redis provider from **Integrations**, then use **Database: Connect to Database** from the command palette or create a saved connection in **Settings > Database**. The default Redis port is `6379`. ## What You Can Do - Scan keys by pattern - Inspect key type, TTL, and value data - Edit values where supported - Delete keys where supported - View server information when available ## Notes Redis is key-value based, so the viewer is organized around key scanning and selected key details instead of table browsing. ## Troubleshooting Check the host, port, password and TLS requirements. Deleting a key changes the connected server; inspect the key and TTL first. See [Database viewer](https://athas.dev/docs/database-viewer) for shared connection and editing behavior. --- # AI Source: https://athas.dev/docs/ai Understand the AI features in Athas and choose the right workflow. Athas has several AI surfaces. They share provider and model settings, but they are built for different jobs. ## Pick the Right Tool | Surface | Use it for | | ------------------------------------------ | ------------------------------------------------------------------------------ | | [Athas Agent](https://athas.dev/docs/athas-agent) | Chat with a model, ask questions about code, and work with project context | | [Inline AI](https://athas.dev/docs/inline-ai) | Get completions while typing or rewrite selected code in place | | [External Agents](https://athas.dev/docs/external-agents) | Run CLI coding agents published in the Integrations catalog | | [Providers and Models](https://athas.dev/docs/ai-providers) | Configure API keys, Ollama, OpenRouter, and custom OpenAI-compatible endpoints | ## How Configuration Works AI settings live in **Settings > AI**. - A default model is shared by new chats and other AI features unless overridden - Other features can select their own model under **Settings > AI > Other features** - Tab completion has a separate model picker - Custom OpenAI-compatible endpoints can be used for either Athas Agent or autocomplete - API keys are stored locally in secure storage - Local chat history can be cleared from the same settings page ## Context and tools Use [Agent context](https://athas.dev/docs/agent-context) to configure project rules and excluded paths. [MCP servers](https://athas.dev/docs/mcp) provide additional tools; their transport support depends on the agent. ## Providers Athas supports built-in providers, Ollama, OpenRouter, and custom OpenAI-compatible endpoints. For setup details, see [Providers and Models](https://athas.dev/docs/ai-providers). ## Hosted AI Pricing Pro includes $10 of hosted AI usage each month, on both monthly and annual subscriptions. Hosted autocomplete, inline edits, commit messages, drafts, integration generation, and hosted Agent models share this credit. It refreshes monthly and unused credit does not roll over. Every hosted request costs the model's list price plus 10%, for the included credit and for any balance you add. When the included credit runs out, hosted models continue from a prepaid balance you top up in $20 steps, up to a monthly limit you set. Pro is not required to use a prepaid balance. Your billing settings show each model's list price and the rate you pay, plus available, used, and pending amounts; pending amounts settle once usage is confirmed. Most hosted models, and Automatic, read images: paste a PNG, JPEG, GIF or WebP screenshot of up to 1.5 MB into the Agent composer. When the selected model reads text only, Athas leaves the image out and says so. Personal provider keys and local models never use the credit or the balance. Browser usage is billed separately. ## Choose the next step Configure a connection in [Providers and Models](https://athas.dev/docs/ai-providers), give it [project context](https://athas.dev/docs/agent-context), then choose [Athas Agent](https://athas.dev/docs/athas-agent) for a local task. --- # Athas Agent Source: https://athas.dev/docs/athas-agent Use the built-in coding agent with project context, tools, permissions, and reviewable edits. Athas Agent is the built-in coding agent. It can answer questions, inspect your workspace and use supported tools to make changes. Its model and connection come from your AI settings. ## Start a task 1. Open the AI panel or choose **New Athas Agent** in the command palette. 2. Select a model with the capabilities your task needs. 3. Describe the expected behavior, relevant files and constraints. 4. Attach a selection with **Add Selection to Agent Chat** when it helps explain the task. 5. Inspect tool requests and review the resulting changes. For example: “Find why this test fails, fix the cause, and run the relevant suite. Preserve unrelated edits and summarize any remaining failure.” ## Models and context Choose the default model in **Settings > AI**, or override **New chats** under **Other features**. See [Providers and Models](https://athas.dev/docs/ai-providers) for keys, Ollama and custom endpoints. [Agent context and instructions](https://athas.dev/docs/agent-context) explains project rules and excluded paths. ## Permissions and review Review the operation and scope when Athas asks for permission. Read a file diff before accepting an agent edit and inspect command results before assuming tests passed. A provider's capabilities and your organization policy can limit the tools or models available. **Follow Agent** controls whether the editor follows files the agent opens. **Steps before pausing** limits model requests per turn before asking to continue. Both are in AI agent settings. ## Extend or share a session [MCP servers](https://athas.dev/docs/mcp) can add tools. [Share to Web](https://athas.dev/docs/sharing) creates a read-only snapshot; private cloud session sync is a separate opt-in feature. [External agents](https://athas.dev/docs/external-agents) run their own coding CLIs. --- # Inline AI Source: https://athas.dev/docs/inline-ai Choose Tab completion separately from inline edits and review generated changes in the editor. Inline AI includes suggestions while typing and targeted edits to code in the active editor. The two surfaces have separate model choices. ## Tab completion Open **Settings > AI > Tab completion**, enable suggestions and choose a model. Automatic uses the available connection described by the picker. Check its provider before assuming a completion is local. Organization policy can disable completion. Use a model suitable for fast coding suggestions. For a personal or local connection, configure it first in [Models & keys](https://athas.dev/docs/ai-providers). ## Inline edits Select the code you want changed and run **Agent Inline Edit** from the command palette. Describe the focused change, inspect the generated result and keep or reject it before continuing. Inline edits use the default model unless **Inline edits** has an override under **Settings > AI > Other features**. Changing the Tab completion model does not set the inline-edit model. ## Context and failures Keep the selection small enough to review. Root ignore files affect automatic context and Tab completion; see [Agent context](https://athas.dev/docs/agent-context). If a request fails, check the chosen connection, key or endpoint and hosted usage limits in [Providers and Models](https://athas.dev/docs/ai-providers). Use [Athas Agent](https://athas.dev/docs/athas-agent) for tasks that need broader discussion or multiple files. --- # Providers and Models Source: https://athas.dev/docs/ai-providers Choose default and feature models, configure provider keys or local endpoints, and diagnose connection failures. Model settings choose where requests go. The selected connection determines whether usage is charged through Athas, a personal provider key, or a local server. ## Default and feature models Open **Settings > AI** and choose the **Default model**. New chats and other AI features use that connection unless a feature has an override. Expand **Other features** to choose separate models for new chats, inline edits, commit messages, titles, GitHub drafts or review assistance. **Tab completion** has its own page and model choice. Its Automatic option resolves according to your available Athas or personal/local connection. Inspect the displayed model and provider before assuming a request stays on-device. ## Personal provider keys Open **Settings > AI > Models & keys**. Set the key for the provider you want to use, then select one of its available models. Athas includes OpenAI, Anthropic, OpenRouter, Gemini and xAI provider setup. Use the provider's official account console to create and manage keys; their access and billing are separate from your Athas subscription. Keys are stored locally through secure storage. External agents have their own authentication; adding a provider key to Athas does not automatically sign every external CLI into its service. ## Ollama Install and run [Ollama](https://ollama.com), then pull a model supported by your machine: ```bash ollama pull ollama list ``` Configure the endpoint in **Models & keys**, then select the Ollama model. A local endpoint keeps model execution on that machine; an Ollama Cloud endpoint is a remote service and may need a key. Model availability, context size and tool support depend on the model and server. ## Custom OpenAI-compatible endpoint Configure **Custom** under **Models & keys** with: - The exact model ID expected by your server. - Its API base URL, such as `http://localhost:11434/v1`. - An API key if the server requires bearer authentication. Athas accepts an API root or full chat completions URL, such as `https://api.example.com/v1/chat/completions`. The endpoint must implement the supported OpenAI-compatible chat completions API. Custom model IDs are entered directly, not discovered automatically. Select the custom connection in the default, feature or Tab completion model picker as needed. ## Troubleshooting | Symptom | Check | | -------------------------- | ---------------------------------------------------------------- | | Authentication error | Correct provider, key validity and account permissions | | Model not found | Exact model ID and endpoint URL | | Local connection refused | Server running, host and port reachable | | Hosted credit or cap error | Athas billing usage, available credit and monthly spending limit | | Tool calls unavailable | Selected model and endpoint's tool-calling support | | External agent login error | That agent's CLI login and account setup | Never paste keys into a bug report or chat. [AI overview](https://athas.dev/docs/ai) explains hosted usage and [Agent context](https://athas.dev/docs/agent-context) describes which project information an agent receives. --- # External Agents Source: https://athas.dev/docs/external-agents Run installed CLI coding agents from the Athas AI panel. External Agents are CLI coding agents that Athas can run inside the AI panel. Use them when a task needs file edits, command execution, tests, or multi-step project work. See the [Integrations catalog](https://athas.dev/integrations) for the current list of supported agents. ## Getting Started 1. Open **Integrations** and switch to the **Agents** filter. You can also browse the public [Integrations catalog](https://athas.dev/integrations). 2. Click **Install** next to the agent you want to use. 3. Open the AI panel and select the installed agent from the dropdown. 4. Send a message. Athas starts the selected agent when the conversation begins. **Info:** Athas installs supported agents as managed tools from **Integrations > Agents**. If you already installed an agent globally, Athas detects it and uses that binary instead. ## Managed Installation The **Install** button uses the agent contribution published in the integrations catalog. It installs the underlying agent or ACP adapter as a managed command-line tool and writes an ACP wrapper that Athas can run. For agent availability and descriptions, use the [Integrations catalog](https://athas.dev/integrations) or the **Agents** filter in Athas. **Info:** Some agents still require their own login or API setup after installation. If an agent reports an authentication error, complete login in that agent's CLI and retry from Athas. ## What Agents Can Do - Read and write files in your project - Run terminal commands to build, test, or install packages - Search your codebase for relevant context - Make multi-file changes in a single conversation ## Permissions When an agent wants to edit a file or run a command, Athas shows a permission prompt. - Click **Allow** to approve the action - Click **Deny** to reject it ## Slash Commands and Modes Some agents expose slash commands such as `/web`, `/compact`, or `/init`. Available commands depend on the selected agent. Some agents also expose modes such as Code, Plan, or Ask. When supported, use the mode selector in the chat header. ## When an agent will not start Check the integration’s installed state, required runtime and CLI login. Run the agent’s own help or login command in a terminal to inspect its setup. [Athas provider keys](https://athas.dev/docs/ai-providers) and external CLI credentials are separate. Configure supported [MCP servers](https://athas.dev/docs/mcp) and [project rules](https://athas.dev/docs/agent-context) for the selected agent. --- # Agent context Source: https://athas.dev/docs/agent-context Give agents useful project context, set repository rules, and understand ignore-file boundaries. Give an agent the relevant files, a concrete task and a way to verify the result. Context and permissions are separate: an instruction file describes how to work; it does not grant access. ## Provide a focused task A useful request states the expected behavior, constraints and verification: ```text Fix the settings form so invalid URLs show an error before saving. Use the existing validation and field components. Keep unrelated changes. Run the relevant form tests and summarize the changed files. ``` Attach selected code through **Add Selection to Agent Chat**, and include the error or failing check. Let the agent inspect the project instead of pasting an entire repository into a prompt. ## Project and user instructions The built-in agent loads project instructions from `AGENTS.md`, `CLAUDE.md`, `.athas/rules`, and `.cursor/rules`. Put shared conventions and test commands near the project they describe. Set cross-project **User rules** under **Settings > AI > Agents**. External agents use their own configuration and supported instruction formats. Check that agent's instructions rather than assuming it reads every format Athas understands. ## Exclude automatic context Root `.athasignore`, `.aiignore`, and `.cursorignore` files exclude paths from automatic context, Tab completion and built-in workspace tools. Use them for generated or irrelevant files. These are context filters, not a security sandbox. External agents, terminal commands and MCP tools follow their own access rules. Keep secrets out of the workspace context and inspect permission requests before allowing actions. ## Review results Inspect file edits, command output and relevant tests before accepting a change. Use a [worktree](https://athas.dev/docs/git-worktrees) to isolate larger tasks. See [Athas Agent](https://athas.dev/docs/athas-agent), [External agents](https://athas.dev/docs/external-agents) and [MCP servers](https://athas.dev/docs/mcp) for each execution path. --- # MCP servers Source: https://athas.dev/docs/mcp Connect agent tools through MCP and understand transport, credentials, and permissions. Model Context Protocol (MCP) servers expose tools to an agent, such as searching a service or reading a database. Only configure a server whose executable or endpoint you trust. ## Add a server Open **Settings > AI > MCP servers** and add a server. Choose the transport the server supports and enter its command or endpoint. Configure required environment variables or headers without putting secret values into project instructions. Athas supports stdio, HTTP and SSE transports. A stdio server runs a local command; a remote transport connects to the configured URL. Use the server's own setup instructions for arguments, credentials and required runtimes. ## Select servers for agents Enable the server to pass it to agents. An external agent may support only some transports; Athas reports configured servers that were left out because that agent cannot use them. A saved server definition alone does not prove the server connected or the agent can call its tools. ## Permissions and data Read the tool name, arguments and scope before allowing a call. A tool can read or modify data outside the editor, depending on the server's permissions. Project ignore files do not restrict an MCP server's independent access. ## Connection problems - For stdio, confirm the command works and its runtime is available. - For remote servers, verify the URL, transport and required headers. - Confirm credentials have the intended scope and have not expired. - Check the selected agent supports the transport, then restart the affected session after changes. See [Agent context](https://athas.dev/docs/agent-context) for instruction and ignore files, and [Providers and Models](https://athas.dev/docs/ai-providers) for model connections. ## Install links Server authors can offer an [Add to Athas link](https://athas.dev/docs/mcp-servers#add-to-athas-links) that pre-fills the server dialog. Review the command, endpoint and credentials before saving. --- # MCP Servers Source: https://athas.dev/docs/mcp-servers Give agents in Athas extra tools with Model Context Protocol servers. MCP servers give the agents you run in Athas extra tools, such as access to a database, a browser, or your issue tracker. Athas passes every enabled server to agents when a session starts. ## Adding a Server 1. Open **Settings > AI > MCP Servers**. 2. Click **Add Server**. 3. Pick a transport: - **Stdio** runs a command on your machine, for example `npx -y @modelcontextprotocol/server-filesystem ~/projects`. - **HTTP** or **SSE** connects to a remote server URL. 4. Add any environment variables or headers the server needs. Athas keeps these in secure storage, not in the settings file. Use the switch next to a server to stop passing it to new agent sessions without removing it. ## Add to Athas Links Server authors can offer a one-click install link. Opening it shows the MCP server dialog with the server filled in; nothing is saved until you review it and click save. ```text athas://mcp/install?name=&config= ``` The config uses the same shape as an `mcp.json` entry and Cursor install links: ```json { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "~/projects"] } ``` ```json { "url": "https://mcp.example.com/mcp", "headers": { "Authorization": "Bearer " } } ``` Add `"type": "sse"` for servers that use the SSE transport. GitHub and most Markdown renderers drop `athas://` links, so README buttons should point at the https version, which opens Athas for the reader: ```md [![Add to Athas](https://athas.dev/badges/add-to-athas.svg)](https://athas.dev/mcp/install?name=Filesystem&config=) ``` To build the `config` value, base64-encode the JSON and URL-encode the result: ```bash printf '%s' '{"command":"npx","args":["-y","@modelcontextprotocol/server-filesystem"]}' | base64 | tr -d '\n' | jq -sRr @uri ``` --- # Share to Web Source: https://athas.dev/docs/sharing Share read-only snapshots of editor buffers, code selections, and agent conversations. Sign in to your Athas account, then create a snapshot link hosted on athas.dev. Public sharing is available on the free plan. Viewers do not need an account for public links. ## Share content - Select code, right-click, and choose **Share Selection to Web**. - Right-click in an editor and choose **Share Buffer to Web** to include the current buffer, including unsaved changes. - Use **Share agent to web** in the agent header to share its conversation. These actions are also available in the command palette. Review the content, choose visibility, and click **Create link**. Athas copies the link to your clipboard. Enable **Keep this link up to date** for an agent session or buffer to include future responses and edits. Leave it off to create a fixed snapshot. Selections are always fixed snapshots. Live links update while Athas is running and the source is available, usually within a few seconds. The web view uses Athas editor colors, fonts, line numbers, and conversation layout. It is read-only. Agent snapshots include visible user and assistant text, including responses that used tools, and show your account name and profile photo. Local paths in conversation text are redacted. They do not include system prompts, tool payloads, or image attachments. Code snapshots preserve the selected text exactly. ## Visibility **Public** is the default. Anyone with the link can view the snapshot. **Specific emails** requires Athas Pro. Recipients sign in using Google, GitHub, or Apple with an allowed, verified email address. If they signed in before this feature was available, they should sign in again to verify their address for sharing. **Organization** requires Athas Pro. Choose an organization you belong to. Only its active members can view the link; removing a member also removes their access. The creator can always view their snapshot. Restricted snapshots stay restricted if the creator's Pro plan expires. Open **Settings → Sharing & cloud** in Athas or on the [web dashboard](https://athas.dev/dashboard/settings/sharing) to copy or revoke links, change access, and pause or resume live updates. Revoking a link disables it. Snapshots support up to 500,000 characters, with a 2 MB upload limit and 100 new links per account per day. ## Private cloud sessions Enable **Sync agent sessions** in **Settings → Sharing & cloud** to upload existing agent conversations and keep future responses in sync. This is separate from cloud settings sync. Your cloud sessions are private to your signed-in account; enabling sync never publishes them. Read them under **Private sessions** on the web dashboard. Turning sync off in either app stops future uploads and retains existing cloud copies. Delete a private session from the web library to remove its cloud copy; Athas will not upload that session again automatically. Your local conversation is kept. The library supports up to 2,000 sessions, with the same per-session text limits as sharing. Image attachments and tool payloads stay local. ## Review and revoke access Inspect the selected buffer or conversation before creating a public link. Snapshot sharing, live updates and private session sync have different visibility. Revoke a link from Sharing & cloud when it is no longer needed. --- # Collaboration Source: https://athas.dev/docs/collaboration Use Teams workspace invites, roles, channels, presence, and metadata updates. Collaboration is the Teams workspace layer for using Athas with a small team. ## Availability Collaboration is available on Teams workspaces. Owners, admins, and accepted members see the same workspace data in the web dashboard and Athas desktop. Free and Pro accounts see an upgrade prompt instead. ## Dashboard Open **Dashboard > Settings > Collaboration** to manage the workspace: - invite teammates and copy invite links - review members and pending invitations - change roles or disable members - create workspace channels - edit channel notes - add channel guests - share workspace projects - review recent activity - adjust invite rules, seat limits, and update limits Owners and admins can manage membership and workspace rules. Members can use shared projects, channels, and presence where enabled. ## Desktop Athas desktop shows a compact Collaboration settings tab when the signed-in account has Teams workspace access. The desktop tab shows: - workspace membership summary - pending invitations - channels - active presence state - current document stream status Detailed member, channel, invite, and policy changes live in the web dashboard. ## Presence Desktop can publish a lightweight presence heartbeat with the active file path, selected channel, and optional follow target. This is metadata only; it does not sync editor contents. ## Realtime Documents Desktop can register the active document and append metadata-only update events for cursor, selection, and viewport state. The server stores document paths, versions, and event metadata without uploading source contents. This is the transport foundation for future shared editing. Live co-editing, automatic merges, voice, screen sharing, and email delivery are not part of this slice yet. ## Roles - `owner`: manages the billing-owned workspace - `admin`: manages members, invitations, and workspace rules - `member`: uses shared projects, channels, and presence - `viewer`: read-only workspace access ## Choose the right sharing feature Use [Share to Web](https://athas.dev/docs/sharing) for a read-only code or conversation link. Collaboration presence/cursor metadata does not synchronize source contents; keep code changes in Git and do not expect live co-editing. --- # Dashboard integrations Source: https://athas.dev/docs/dashboard-integrations Connect GitHub, Linear, Vercel, and Sentry to your Athas inbox. Open **Integrations** in the [web dashboard](https://athas.dev/dashboard/settings/integrations) to browse apps, search by name, or filter by category. Connected apps show their connection status. Each connection belongs to your account. ## Connect an app Click an app card to view its capabilities, or choose **Connect** to start setting it up. The menu beside it provides links to the provider and its credential settings. - **GitHub:** Choose **Continue with GitHub** and authorize the application. GitHub supplies issues, pull requests, notifications, workflow runs, and releases. Use **Repositories** in the connection panel to manage repository sync. - **Linear:** Create a [personal API key](https://linear.app/settings/api) with Read permission for your teams. Paste it into the connection panel. Athas reads your 50 most recently updated assigned issues, including their project, priority, and workflow state. - **Vercel:** Create an [access token](https://vercel.com/account/settings/tokens). Enter a team slug if you want team deployments, or leave it empty for your personal account. The token must have access to the selected account. Athas reads its 50 latest deployments and build states. - **Sentry:** Create a [personal auth token](https://sentry.io/settings/account/api/auth-tokens/) with `event:read`, then enter your organization slug. Athas reads the 50 most recently seen issues from the last 14 days, including resolved issues. This connection supports Sentry Cloud at `sentry.io`. Linear, Vercel, and Sentry credentials are checked against the provider before saving. The first activity sync completes as part of connecting. A rejected token does not replace an existing connection. ## Sync and manage Open **Manage**, then choose **Sync now** to update the inbox. These integrations sync on demand, with up to 50 items per sync; they are not a complete historical import. Repeated syncs update matching items without resetting their Athas triage status. Choose **Open inbox** to see items from that integration. Source links take you to the original issue or deployment. Athas does not write changes back to Linear, Vercel, or Sentry. Use **Update token** when credentials expire or their permissions change. Sync failures appear in the connection panel and mark the app as needing attention. Disconnecting removes the saved credential and stops future syncs. Previously imported items stay in your inbox. Revoke personal tokens in the provider's settings if you no longer need them. Disconnecting GitHub also revokes its application authorization when the server's OAuth credentials are configured. ## Troubleshooting Check the connection's error, provider account and token scope before reconnecting. If a provider reports revoked or expired credentials, update the token. Items are an on-demand sync of recent activity, not a full historical mirror. Use source links for actions on the provider. See [GitHub Integration](https://athas.dev/docs/github-integration) for GitHub token behavior and [Troubleshooting](https://athas.dev/docs/troubleshooting) for a useful support report. ## API references The connectors use the documented [Linear GraphQL API](https://linear.app/developers/graphql), [Vercel deployments API](https://vercel.com/docs/rest-api/deployments/list-deployments), and [Sentry organization issues API](https://docs.sentry.io/api/events/list-an-organizations-issues/). --- # Enterprise controls Source: https://athas.dev/docs/enterprise Understand managed workspaces, integration allowlists, and organization AI policies. Enterprise workspaces can apply policies to desktop configuration and AI access. Your account must have enterprise workspace access; ordinary local projects do not create an enterprise policy. ## Inspect the policy Open **Settings > Enterprise** while signed in. Administrators can update policy controls; other members see the policy in read-only form. If the policy cannot load, refresh your session before assuming a control is unavailable. ## Available controls | Control | Purpose | | --------------------- | ----------------------------------------------- | | Managed mode | Apply organization management to settings | | Integration allowlist | Restrict installed integrations to approved IDs | | Bring your own key | Allow or restrict personal provider keys | | AI completion | Enable or disable AI completions | | AI chat | Enable or disable AI chat | Administrators enter integration IDs in the allowlist, separated by commas or newlines, and save the policy. Use the catalog's actual IDs rather than display names. ## When a setting is locked A disabled control can reflect organization policy. Ask your workspace administrator to inspect the policy; changing a local setting is not a way to override it. A policy restriction and a missing provider key are different causes of unavailable AI. See [Providers and Models](https://athas.dev/docs/ai-providers) for model setup, [Integrations](https://athas.dev/docs/integrations) for the catalog, and [Enterprise](https://athas.dev/enterprise) for organization rollout options. --- # Settings Source: https://athas.dev/docs/settings Customize Athas across appearance, editor, Git, terminal, AI, account, and advanced controls. ## General - [Check for updates](https://athas.dev/docs/updates) and install new desktop releases - Install, copy, or uninstall the `athas` terminal command - Import matching setup from another editor - Choose where to report a bug with environment details ## Import Settings from Other Editors Use **Settings > General > Import Settings** to import compatible setup from another editor through a command-palette style picker. Athas currently imports recent local projects from VS Code-family editors, Cursor, Windsurf, Zed, and JetBrains IDEs. The flow is designed to grow into matching settings, keybindings, integrations, and other compatible setup data as those mappings become available. ## Appearance - Switch color themes and upload custom theme JSON files - Pick an icon theme and separate UI font family and size - Sync light and dark themes with the OS - Change sidebar position, sidebar tab layout, title bar project mode, and GitHub sidebar section visibility - Choose whether opening another project uses a new window ## Features - Turn major product surfaces on or off, including GitHub, Remote, Terminal, Search, Diagnostics, AI, Breadcrumbs, and Persistent Commands ## Editor and Files - Tune editor font, size, tab size, wrapping, line numbers, minimap, and max open tabs - Enable relative line numbers for Vim mode - Turn on Auto Save - Route files to an external terminal editor such as Neovim, Helix, Vim, or a custom command - Hide files and directories in Files with comma-separated glob patterns ## Git - Enable or disable Git integration - Control Git panel behavior with auto refresh, discard confirmation, folder-based changes, staged ordering, and empty-section collapsing - Choose the default diff layout and whether clicking a changed file opens the diff directly - Show Git status decorations in Files, inline blame in the editor, and Git gutter markers See [Git Integration](https://athas.dev/docs/git-integration), [GitHub Integration](https://athas.dev/docs/github-integration), [Git Branches](https://athas.dev/docs/git-branches), and [Diff Viewer](https://athas.dev/docs/git-diff). ## Terminal - Choose a default shell and default profile for new tabs - Create custom terminal profiles with shell overrides, startup directories, and startup commands - Turn shell integration (command marks, exit codes, directory tracking) and command notifications on or off - Tune terminal font, scrollback, minimum contrast, cursor style, blinking, and cursor width See [Terminal](https://athas.dev/docs/terminal) and [CLI](https://athas.dev/docs/cli). ## Language and Keyboard - Set the default language or keep auto-detection enabled - Enable format on save, lint on save, auto completion, and parameter hints - Switch keybinding presets, enable Vim mode, and edit shortcuts in the keybindings editor - Import or export custom keybindings See [Keymaps](https://athas.dev/docs/keymaps), [Vim](https://athas.dev/docs/vim), [Language servers](https://athas.dev/docs/language-servers) and [Formatting](https://athas.dev/docs/formatting). ## AI, Integrations, and Databases - Choose a default model and overrides for new chats, inline edits and other features - Configure personal provider keys, Ollama and custom endpoints in **AI > Models & keys** - Configure Ollama for local or cloud use, including endpoint and API key - Configure **AI > Tab completion** independently from inline edits - Set agent user rules, behavior and permissions, and connect MCP servers - Clear local chat history - Install, update, remove, and search integrations across languages, themes, icons, databases, and custom UI integrations - Manage saved network database connections and open SQLite or DuckDB files with the built-in viewer See [AI](https://athas.dev/docs/ai), [Athas Agent](https://athas.dev/docs/athas-agent), [Inline AI](https://athas.dev/docs/inline-ai), [External Agents](https://athas.dev/docs/external-agents), [Providers and Models](https://athas.dev/docs/ai-providers), [Database Viewer](https://athas.dev/docs/database-viewer), [SQLite](https://athas.dev/docs/sqlite), [DuckDB](https://athas.dev/docs/duckdb), [PostgreSQL](https://athas.dev/docs/postgresql), [MySQL](https://athas.dev/docs/mysql), [MongoDB](https://athas.dev/docs/mongodb), [Redis](https://athas.dev/docs/redis), and [Integrations](https://athas.dev/docs/integrations). ## Account and Enterprise - Sign in, view your current plan, open billing, and manage your Athas account - [Enterprise workspaces](https://athas.dev/docs/enterprise) can enforce managed mode, integration allowlists, BYOK policy, and AI feature access ## Advanced - Turn anonymous usage telemetry on or off - Inspect the local telemetry log - Reset all settings back to defaults See [Telemetry](https://athas.dev/docs/telemetry). ## Find a setting Use Settings search rather than scanning every section. A disabled setting can be controlled by [enterprise policy](https://athas.dev/docs/enterprise). Keep a backup before resets and inspect [Troubleshooting](https://athas.dev/docs/troubleshooting) when a setting does not take effect. --- # Themes Source: https://athas.dev/docs/themes Create, import, and manage custom Athas color themes Athas includes light and dark themes and supports persistent custom themes through JSON files. ## Change the active theme 1. Open **Settings** with `Cmd+,` on macOS or `Ctrl+,` on Windows and Linux. 2. Go to **Appearance**. 3. Choose a theme under **Color Theme**. You can also open the Command Palette, search for **Change Theme**, and select a theme. Moving through the results previews each theme before you confirm it. ## Create a custom theme The built-in generator gives you a complete starting file based on any installed theme: 1. Open **Settings → Appearance → Custom Themes**. 2. Select **Create**. 3. Enter a display name and a unique ID. 4. Choose the installed theme you want to use as a base. 5. Edit the generated JSON. 6. Select **Install Theme** to use it immediately, or **Save JSON** to keep the file without installing it. The editor validates the JSON before saving or installing it and shows the exact property path for each problem. ## Import a theme Select **Import** under **Settings → Appearance → Custom Themes** and choose a `.json` file. You can also import from the theme picker in the Command Palette. Imported themes are stored by Athas and remain available after restarting the app. A file can contain multiple variants, such as one light theme and one dark theme. Importing the same custom theme ID again updates that theme. Built-in and integration theme IDs cannot be overwritten. Use the remove button beside an imported theme in Appearance settings to uninstall it. If the removed theme is active, Athas switches back to the matching default theme. ## Theme file format A theme file contains family metadata and a non-empty `themes` array: ```json { "name": "Forest", "author": "Your name", "description": "Muted forest colors", "version": "1.0.0", "themes": [ { "id": "forest-night", "name": "Forest Night", "description": "A dark forest theme", "appearance": "dark", "colors": { "primary-bg": "#161a17", "secondary-bg": "#101311", "text": "#e7ebe8", "text-light": "#bdc7c0", "text-lighter": "#7f8d84", "border": "#2b332e", "hover": "#202722", "selected": "#29322b", "accent": "#8fb996", "error": "#df8175", "warning": "#d7ad70", "success": "#8fb996", "info": "#82aeb8", "selection-bg": "rgba(143, 185, 150, 0.25)" }, "syntax": { "comment": "#738078", "keyword": "#df8175", "string": "#82aeb8", "number": "#d7ad70", "function": "#a4c99f", "variable": "#c4a7cb", "constant": "#df8175", "property": "#8ab7dc", "type": "#b8c98f", "operator": "#a3aaa5", "punctuation": "#a3aaa5" } } ] } ``` Each theme requires: - `id`: starts with a lowercase letter or number and contains only lowercase letters, numbers, dots, underscores, or hyphens - `name`: the label shown in Athas - `appearance`: either `dark` or `light` - `colors`: the UI color map The required UI colors are `primary-bg`, `secondary-bg`, `text`, `text-light`, `text-lighter`, `border`, `hover`, `selected`, and `accent`. The `syntax` map is optional. Athas supplies readable syntax defaults for missing entries. Common entries include `comment`, `keyword`, `string`, `number`, `function`, `variable`, `constant`, `property`, `type`, `operator`, `punctuation`, `boolean`, `null`, `regex`, `tag`, and `attribute`. Additional UI colors can control cursors, selections, Git status colors, and terminal ANSI colors. The generator includes every color supported by its selected base theme, making it the easiest way to discover and customize the full set. ## Troubleshooting imports Athas reports invalid JSON separately from schema errors. Schema messages include paths such as `themes[0].colors.primary-bg`, so you can locate the failing value directly. If a file from VS Code or another editor fails to import, convert it to the Athas structure above first. Other editors use different token names and theme schemas, so their files are not directly compatible. ## Share or maintain a theme Keep the source JSON in version control and re-import the same ID to update it. Personal theme imports do not publish to the [Integrations catalog](https://athas.dev/docs/integrations). [Settings](https://athas.dev/docs/settings) keeps editor and UI fonts separate from color themes. --- # Keymaps Source: https://athas.dev/docs/keymaps Inspect default shortcuts, select a preset, and customize bindings for your focused pane. Athas shortcuts are configurable. `Cmd/Ctrl` in these docs means Command on macOS and Control on Windows/Linux. A selected preset, a custom binding, or the focused pane can change an action's keys. ## Inspect and customize Open Settings (`Cmd+,` on macOS, `Ctrl+,` elsewhere) and go to **Keyboard**. Search for a command, inspect its binding and edit it with the shortcut recorder. Use import/export for custom keybindings. Choose a keybinding preset if you want a familiar starting point. ## Common default shortcuts | Action | Shortcut | | ------------------ | ------------------ | | Open folder | `Cmd/Ctrl+O` | | Quick Open | `Cmd/Ctrl+P` | | Command palette | `Cmd/Ctrl+Shift+P` | | Save | `Cmd/Ctrl+S` | | Save as | `Cmd/Ctrl+Shift+S` | | Save all | `Cmd/Ctrl+Alt+S` | | Close tab | `Cmd/Ctrl+W` | | Reopen tab | `Cmd/Ctrl+Shift+T` | | Find in editor | `Cmd/Ctrl+F` | | Global search | `Cmd/Ctrl+Shift+F` | | Source Control | `Cmd/Ctrl+Shift+G` | | Show/hide terminal | `Cmd/Ctrl+J` | | Show/hide sidebar | `Cmd/Ctrl+B` | ## Focus and conflicts A binding may apply only while the editor or terminal has focus. For example, `Cmd/Ctrl+D` selects the next occurrence in the editor but splits a focused terminal to the right. Check the current focus and keymap when a shortcut invokes the wrong action. [Diagnostics](https://athas.dev/docs/diagnostics) uses `Cmd/Ctrl+Shift+J` in the Athas preset and `Cmd/Ctrl+Shift+M` in the VS Code preset. [Vim mode](https://athas.dev/docs/vim) adds editor-local modal bindings. The command palette shows the current action and remains the easiest way to discover available commands. --- # Vim mode Source: https://athas.dev/docs/vim Enable modal editing, use supported Vim commands, and resolve shortcut conflicts. Vim mode adds modal editing to the Athas editor. It does not load your Neovim configuration or provide a Neovim plugin runtime. ## Enable Vim mode Turn on **Vim Mode** in Settings. Enable relative line numbers if you prefer them for movement. Use `i` to enter Insert mode and `Esc` to return to Normal mode. The command palette also includes **Vim: Enter … Mode** actions. ## Common commands | Command | Action | | -------------------- | ------------------------------------------------ | | `:w` | Save current file | | `:wq` or `:x` | Save and close current file | | `:q` | Close current file through the normal close flow | | `:q!` | Force close current file without saving | | `:command` or `:cmd` | Open the command palette | | `:explore` or `:Ex` | Open file navigation | | `:preview` | Toggle Markdown preview for a Markdown buffer | Start with a disposable file when learning commands that delete text or close unsaved buffers. ## Shortcuts and focus Vim handles keys inside the editor, while Athas shortcuts control workspaces and other panes. Bindings can depend on Normal/Insert mode and on which pane has focus. Inspect [Keymaps](https://athas.dev/docs/keymaps) when a shortcut behaves differently from your usual editor. For a full external terminal editor, choose Neovim, Helix, Vim, or a custom command in the editor settings. That workflow uses your external executable and configuration. --- # Integrations Source: https://athas.dev/docs/integrations Athas-maintained integrations for languages, tools, agents, and your workspace. Integrations connect Athas to the languages, tools, and services you use. Every integration in the catalog is built and maintained by the Athas team. There is no third-party publishing marketplace. Browse the [Integrations catalog](https://athas.dev/integrations) on the website, or open **Integrations** in Athas from the sidebar or command palette. ## Browse the catalog Use search or a category to find what you need: - **Languages:** syntax support, language servers, formatters, and related tooling. - **Themes and icons:** appearance choices for the editor and file tree. - **Databases:** support for opening and working with supported databases. - **Apps:** connections to developer tools and services. - **Agents:** connections to coding agents and their managed tools. - **Skills:** Athas-maintained instructions for common agent workflows. Athas maintains the integration layer. Connected services, coding agents, and open-source tools retain their own accounts, licenses, and requirements. ## Install and manage Select a card to see its details. Choose **Install** when the integration needs additional tooling. Some integrations are built in and can be used immediately. Installed integrations can offer **Enable**, **Disable**, **Update**, or **Uninstall**, depending on what they provide. Themes and icons can also be selected from Appearance settings. The website opens the matching integration in Athas. Install Athas from the [download page](https://athas.dev/download) if it is not already available on your device. ## Updates The Athas team publishes integration updates through the catalog. Use the update action in the app when a newer version is available. Managed tools may be downloaded separately when an integration is installed or updated. ## Account connections Some services need an account connection or credentials. Manage web account connections from [Dashboard integrations](https://athas.dev/dashboard/settings/integrations). Desktop integrations show their setup requirements in the app. ## Personal customization You can still customize themes, keybindings, and personal skills in their respective settings. Personal customization does not publish an integration to the catalog. ## Requests and contributions Request a new integration or report a problem in the [Athas repository](https://github.com/athasdev/athas/issues). Code contributions go through the Athas team's review and release process; the team maintains the published catalog. ## When a tool is missing Check its installation, enabled state and required runtime. A language grammar, language server and formatter are different contributions. See [Language servers](https://athas.dev/docs/language-servers), [External agents](https://athas.dev/docs/external-agents) or [Database viewer](https://athas.dev/docs/database-viewer) for setup by capability. --- # What's new Source: https://athas.dev/docs/changelog Read Athas release notes, improvements and fixes, then find update and regression guidance. Review every stable Athas release, including new features, improvements, and fixes. ## After upgrading Use [Updates](https://athas.dev/docs/updates) for release channels and installation recovery, and [Troubleshooting](https://athas.dev/docs/troubleshooting) to report a regression with your version and platform. ## Editor, extensions, and Git/GitHub improvements (0.16.1) Released: Thu Oct 08 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.16.1) [Compare changes since v0.16.0](https://github.com/athasdev/athas/compare/v0.16.0...v0.16.1) **Opened files show their text again.** In 0.16.0 the installed app blocked the editor's styles, so files opened from the file tree, quick open or the log view showed an empty editor. The editor now lays out and draws its text as it should. **The title bar uses the full width in macOS full screen.** The sidebar toggle and project switcher no longer sit behind an empty gap left for the hidden window buttons. **The hosted model list matches the new catalog.** Models that were renamed keep your selection under their new names, and models that are no longer offered fall back to automatic selection. [Compare changes since v0.16.0](https://github.com/athasdev/athas/compare/v0.16.0...v0.16.1) [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.16.1) ## Editor, Git/GitHub, and AI improvements (0.16.0) Released: Thu Oct 08 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.16.0) [Compare changes since v0.15.1](https://github.com/athasdev/athas/compare/v0.15.1...v0.16.0) **Athas now runs on a new editor engine built for large files.** Every editor feature moved to CodeMirror 6, including LSP navigation, refactoring, diagnostics, hover, completion, vim, find, the minimap and sticky scroll. Typing in a 200,000-line file costs about the same as in a small one, and the editor no longer re-renders the rest of the window on each keystroke. **Files open noticeably faster.** Clicking a file in the tree paints its text sooner, because indexing, focus, tree updates and other work that can wait now happen after the first frame. Markdown previews update only the blocks you edit, and find, git blame and semantic highlighting no longer rescan the whole file while you type. **You can browse the web in a tab.** Pages open in browser tabs inside the workbench, keep their place when you switch tabs, and stay visible as a snapshot when menus or dialogs open on top of them. **The agent chat is redesigned, and the built-in agent can do more.** Every agent runs in the same chat, with a context meter, steps and cost under answers, keyboard answers to permission prompts and a timeline of past sessions in the sidebar. The built-in agent can use your MCP servers, follows project rules, reviews its changes in a tab and inline in the editor, and keeps checkpoints so you can restore files from before a turn. **Inline edit and Tab autocomplete are easier to use.** Inline edit previews its change as a diff and now shows the instruction, model and actions in two clear rows with their shortcuts. You can start it from the selection toolbar, and Tab autocomplete shows its model and status with real error messages. **Quick open is now a search hub.** Besides files and symbols, it finds Git branches and commits, GitHub pull requests and issues, open tabs and agent sessions. Code outside the editor, such as diffs, search results and the SQL bar, is highlighted with the same grammars as the editor. **Source control and GitHub have a new stream layout.** Changes, history, pull requests, issues and actions read as one stream, and two pull requests opened side by side no longer overwrite each other. **Settings opens in a large dialog with a compact layout.** Settings are grouped into cards with one control style, and a compact UI density can be turned on and is restored at startup. Commands from the palette, menus and shortcuts now share one list, so every action can have a keyboard shortcut. **Your work is safer.** Athas refuses to overwrite files that changed on disk, asks about unsaved changes once when closing tabs or windows, asks before trusting an unknown SSH host key, respects AI ignore files and keeps prompts and file paths out of crash reports. **Terminals and git handle heavy output better.** Terminal output is sent in larger batches, so commands that print a lot use far less work, and terminal tabs can now be cleared and exported from their menu. Git blame stays ready after you commit or switch branches. **Athas uses the system webview on every platform.** The bundled browser engine is gone, which makes the app smaller, and window commands such as full screen, minimize and maximize work from the command palette. [Compare changes since v0.15.1](https://github.com/athasdev/athas/compare/v0.15.1...v0.16.0) [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.16.0) ## Faster navigation and a steadier workbench (0.15.1) Released: Sat Sep 26 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.15.1) Switch between editors and sidebars with less flicker, browse large file trees more smoothly, and check Pro credits from the agents sidebar. **Switching between editors and sidebars feels faster and steadier.** Recently used tabs and sidebar views stay ready when you return to them, preserving their scroll position and loaded content. Startup, terminal placement, and sidebar resizing also show fewer visual jumps. **The file tree stays responsive in large projects.** Scrolling and expanding folders do less repeated work, while folder sizes are measured when you need them. Sticky parent folders remain pinned to the top edge as you browse. **Editor tabs and panes are easier to navigate.** Tabs stay inside their pane, the active tab scrolls into view, and clipped tabs fade at the edge. The outline now docks beside the editor it belongs to, and multibuffer files have a docked list that no longer covers their content. **Settings has its own navigation inside its tab.** Its page list and search no longer replace your workspace sidebar. You can also show or hide the sidebar with Cmd+B, and the activity rail has a terminal toggle with menus that open toward the workspace. **Pro credit usage is easier to check.** A compact ring in the agents sidebar opens a summary of credits left, credits used, the reset date, and billing. Agent diffs also gain syntax highlighting, collapsible previews, and a way to expand longer changes. **Git and integration details are clearer.** Inline blame appears after the cursor rests on a line, and diff actions sit above the commit message. Integration and agent icons remain readable in dark themes. [Compare changes since v0.15.0](https://github.com/athasdev/athas/compare/v0.15.0...v0.15.1) [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.15.1) ## Coding agents and a clearer workbench (0.15.0) Released: Sat Sep 26 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.15.0) Install ACP agents, review their edits in the editor, and follow their plans, tool calls, and terminal output in chat. **Coding agents now work directly in Athas chats.** Install agents from the ACP Registry, sign in with the options they support, and connect configured MCP servers. Their plans, questions, permissions, tool calls, terminal output, and usage details stay with the conversation. **You can review agent edits one hunk at a time.** See the proposed changes in the editor, keep the parts you want, and reject the rest. Athas also tracks edits across chats and keeps your unsaved work when an agent changes a file. **The workbench has a clearer layout.** Editor tabs share the title bar with project navigation, the activity rail makes agents and other views easier to find, and Settings opens as a page with its own sidebar. Markdown preview opens in the same tab and can be toggled from the breadcrumb. **Agent conversations are easier to follow and control.** Tool calls and file diffs appear in the chat timeline, terminal commands can run from the composer, and edited prompts show what changed. Agent sessions retain their options and history, while prompts that need your attention remain visible across tabs. **Linux and WSL projects work more reliably.** Athas runs Git operations inside the WSL distribution for repositories on WSL shares, improves Linux startup and packaging, and supports the required host libraries in release archives. [Compare changes since v0.14.2](https://github.com/athasdev/athas/compare/v0.14.2...v0.15.0) [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.15.0) ## Editor, extensions, and Git/GitHub improvements (0.14.2) Released: Wed Sep 09 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.14.2) Editor, extensions, and Git/GitHub improvements in Athas 0.14.2. **Agent conversations are easier to control and review.** Choose an agent, model, and reasoning effort directly from the composer. Agent windows can be detached, image attachments stay with conversations, and agent edits can be reviewed as diffs. The scroll-to-bottom button now stays in the right place and hides when it is not needed. **Your local sessions can follow you to the dashboard.** Enable cloud session sync to upload existing conversations and new responses privately while Athas is running. The dashboard's Sessions page shows recent activity, supports search, and refreshes automatically. You can also share editor content and agent conversations through links with access controls and optional live updates. **GitHub activity is available inside the workbench.** Browse workflow runs, follow live job status, and read logs in the editor. Manage releases and deployments alongside repository activity, with links to the relevant GitHub details. **Terminal splits stay with your workspace.** Drag terminal tabs into resizable panes and restore the layout when returning to a workspace. Shell integration adds command markers and navigation, clearer completion notifications, and improved Windows shell support. Terminal links support explicit modifier-click navigation and OSC 8 hyperlinks. **Team workspaces bring shared project setup together.** Manage workspace repositories, environments, extensions, tasks, and shared AI context from one place. Local project mappings stay separate from the shared configuration. **The workbench has a clearer, more consistent presentation.** Settings use a shared two-pane layout, controls follow consistent sizing and styling, and Athas Light has stronger contrast. Sidebar labels, pane resizing, and workspace restoration have also been refined. **Hosted models and browser tools now have account-aware controls.** Where the hosted services are enabled, signed-in users can access hosted models and isolated browser tasks with separate usage billing. Existing provider keys, local models, and external agents remain available. **Everyday editing and navigation are more reliable.** Definitions open in a full editor, Git diffs preserve non-text changes, and SSH connections handle home-relative key paths more clearly. Typography is bundled with the app, and cached syntax parsers are verified before loading. Full changelog: https://github.com/athasdev/athas/compare/v0.14.0...v0.14.2 [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.14.2) ## Editor, Git/GitHub, and AI improvements (0.14.0) Released: Thu Sep 03 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.14.0) Editor, Git/GitHub, and AI improvements in Athas 0.14.0. **Continuous Agents can now keep workspace goals moving in fresh Agent sessions.** Create and manage scheduled goals from a dedicated resource view with its own sidebar, pause or run them on demand, and return to the latest session without leaving the editor. **Continuous runs now fail safely instead of launching stale or duplicate work.** Athas validates the selected Codex or ACP agent, isolates goals by workspace, waits while another Agent is active, coordinates multiple app windows, preserves transient failures for retry, and pauses tasks that need attention. **Coding agents are easier to discover, install, and update.** Managed and system binaries are detected consistently, the agent picker exposes clear install and update states, and the bundled Claude, Gemini, Copilot, Kimi, OpenCode, and Qwen definitions now track their current upstream releases and supported platforms. **Secondary navigation now gives each tool a focused workspace sidebar.** Source Control, GitHub, Docker, and Continuous Agents own their sections while the primary activity rail stays compact and free of nested subitems. **Branch and project menus remain clean while scrolling.** Shared menu primitives keep search and action rows fixed, isolate overflow correctly, and keep row actions reachable while their submenus are open. **React runtime behavior is safer across the workbench.** This release removes render-time mutations, impure state updates, leaked timers and listeners, stale async updates, and several security and accessibility edge cases found during the React Doctor audit. [Full changelog](https://github.com/athasdev/athas/compare/v0.13.0...v0.14.0) [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.14.0) ## Editor, extensions, and Git/GitHub improvements (0.13.0) Released: Tue Sep 01 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.13.0) Editor, extensions, and Git/GitHub improvements in Athas 0.13.0. **Athas 0.13.0 brings the editor into a more unified, flexible workbench.** Settings now open as a workbench tab, main tabs are draggable, terminal panes integrate with the main surface, the Activity sidebar resizes live, and shared chrome is more consistent across editor, project, and tool views. **Workspace and project workflows are faster and more dependable.** This release centralizes local and remote workspace lifecycle management, improves session restoration and file-provider behavior, adds project management and remote connection entry points to the switcher, and reduces resource use for inactive workspaces. **AI, agent, and review tools are substantially more capable.** Agent integrations have been modernized with structured tool results, reliable session lifecycle handling, editor-selection context, and hunk-based Intelligence review. Built-in model catalogs now include Claude Fable 5.1 and Qwen 3.8 Flash, use current Mistral IDs, and default Anthropic chat to Claude Sonnet 5 while migrating saved selections. **Source Control, debugging, and navigation received focused upgrades.** Review is now part of Source Control, repository and branch selection are unified, commit controls are clearer, debugger actions and breakpoints are easier to reach, Outline remains available for editor tabs, and file-tree folder arrows can be configured without compact folders being forced on. **Extensions and language tooling cover more real-world workflows.** Extension views are responsive and more strongly typed, installs can be interrupted, Vercel and v0 integrations are externalized, database extension delivery is improved, Java workflows are complete, and managed runtime contracts are more consistent. **Platform polish and reliability extend across macOS, Linux, Windows, and the terminal.** The release improves native macOS workspace integration, restores Linux file dialogs and keyboard support, fixes Vim ex commands and terminal tab shortcuts, stabilizes remote connections, and updates audited Rust networking, XML, and concurrency dependencies. **See every change since 0.12.0 in the full changelog.** https://github.com/athasdev/athas/compare/v0.12.0...v0.13.0 [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.13.0) ## Editor, extensions, and Git/GitHub improvements (0.12.0) Released: Wed Aug 19 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.12.0) Editor, extensions, and Git/GitHub improvements in Athas 0.12.0. - Prime CEF before Linux release packaging - Avoid duplicate Linux package resources - Update the wrapped Athas Linux release - Make GitHub notifications and issues native - Edit issues in place - Keep pull request work in the viewer - Add a rich Markdown document command - Use themed orbs across loading states - Restore native Linux window controls - Fix responsive AI settings and Ollama endpoints - Unify editor toolbar surfaces - Unify onboarding and release notes - Fix AI composer selector layout - Simplify global font and toast styles - Standardize collaboration UI primitives - Standardize command palette composition - Remove the Quick Question flow - Unify sidebar empty states - Contain database sidecar build artifacts - Support directional terminal splits - Route native file drops into terminals - Refine default button group styling - Record durable startup milestones - Defer native startup probes - Keep React Scan out of production startup - Load Monaco panes after workbench chrome - Start background bootstrap after first paint - Batch settings startup persistence - Classify Athas in Linux application menus - Recognize monospaced fonts with incomplete metadata - Add Vim multi-cursor shortcuts - Make ACP authentication errors actionable - Enrich Zig syntax highlighting - Restore Vim Ctrl-R redo - Stabilize file explorer interactions - Keep Vim Ctrl-W inside editor - Keep Vim shortcuts inside Athas - Use Monaco find and replace - Clarify LSP status across themes - Keep Zig identifiers atomic - Keep Monaco hover positioning stable - Separate activity and secondary sidebar shortcuts - Add italic comment preference - Prevent reload-driven renderer stalls - Add worktrees to the activity rail - Unify AI chat preferences - Make agent authentication recovery actionable - Load bundled CEF in preview packages - Simplify sidebar tab switching - Simplify sidebar search controls - Restore default button cursors - Standardize sidebar empty states - Keep GitHub lists stable while refreshing - Open repository selector as a dropdown - Simplify empty state API - Canonicalize Tailwind classes - Improve editor syntax highlighting - Use native Monaco code lenses - Share file navigator tree primitives - Unify Git changes file tree - Unify the main file explorer rows - Improve activity rail spacing and contrast - Use default cursors for trees and tabs - Make file navigators responsive - Keep Git status trees within the sidebar - Keep Git staging controls clear of scrollbars - Keep vertical scroll content within its viewport - Align the uncommitted changes file tree - Share Monaco models across split editors - Make activity rail toggles instant - Parse terminal titles from PTY output - Parse terminal titles from PTY output - Restore Claude through the current ACP adapter - Show selected working tree diff - Use Source Control tree for working diffs - Reduce editor interaction state fanout - Reduce per-edit document scanning - Apply editor line changes incrementally - Decouple cursor movement from editor rendering - Limit Monaco hover measurement work - Remove dormant editor state subscriptions - Index editor symbol breadcrumb lookups - Keep external agents current - Standardize compact shortcut tooltips - Unify new tab and session start views - Limit quick actions to new tabs - Constrain Select styling to semantic options - Make menu item styling semantic - Close pane after the final terminal exits - Enforce semantic UI contracts - Standardize composer selection menus - Unify diagnostics and search result workspaces - Keep editor tab actions visible - Use pill-shaped sidebar rows - Simplify AI composer and history surfaces - Standardize compact rounded menus - Add sidebar worktree actions - Open new AI chats immediately - Keep headless menu triggers geometry-free - Clarify sidebar visual hierarchy - Unbox keyboard shortcuts - Standardize pill-shaped action controls - Show shortcuts in command tooltips - Refine sidebar visual hierarchy - Unify sidebar result rows - Align sidebar tree row radius - Standardize button corner radius - Unify editor and terminal tab surfaces - Flatten vertical terminal surfaces - Consolidate shared menu surfaces - Compact tooltip shortcut chrome - Unify searchable control surfaces - Refine shared popover chrome - Remove redundant AI composer shell - Show the New Agent shortcut - Remove the unused native select - Share the control surface with textareas - Remove unused overlay primitives - Unify active overlay surfaces - Compact shared command panels - Use the shared dialog close control - Unify modal backdrops - Remove unused UI primitive forks - Remove the unused toast fork - Unify floating preview surfaces - Share menu styling with the menubar - Round embedded icon controls - Define the extension package contract - Standardize icon toggles - Resolve toggle shortcuts from commands - Separate extension sources from deployment artifacts - Simplify modal transitions - Remove stale extension package build artifacts - Reuse buttons in combobox controls - Move extension build tooling out of app source - Reuse buttons in select triggers - Tighten shared form radii - Remove the legacy extension installer API - Clarify compact surface hierarchy - Build plan messages from shared cards - Remove duplicate compact menu chrome - Unify extension runtime activation - Put extension features under their owners - Package only extension runtime assets - Retire platform-only extension packages - Separate generated extension runtime concerns - Separate extension language runtime responsibilities - Make notifications readable and immediate - Build the offline catalog from extension sources - Share one extension catalog loader - Move product capability UI to its owner - Standardize sidebar composition primitives - Open action notifications in the native viewer - Move extension browsing into the sidebar - Split extension browser responsibilities - Unify GitHub viewer composition - Separate extension catalog actions - Complete commit file retrieval - Format the GitHub pull request viewer - Align diagnostics with global search - Support AI extension deep links - Align add context with composer actions - Expand agent context sources - Restore bundled icon themes - Anchor composer suggestions to the caret - Simplify agent preferences hierarchy - Send attached file contents to providers - Activate bundled icon themes at startup - Open Extensions as an editor tab - Refresh extension actions after deactivation - Stabilize global search sessions - Unify global search empty states - Align pull request navigation - Keep editor overlays above breadcrumbs - Stabilize editor rendering lifecycles - Add experimental Ghostty terminal engine - Clean up extension catalog cards - Keep search file headers visible - Import VS Code keybindings - Stabilize search result syntax highlighting - Preserve Monaco models across remounts - Align Monaco widgets with the app theme - Unify collaboration sidebar navigation - Keep database rows stable for expanded values - Split Docker sidebar responsibilities - Drop missing workspaces during prewarm - Render supported image formats reliably - Add shared changed-file review navigation - Redesign source control diff reviews - Unify pull request file reviews - Unify activity sidebar interactions - Refine shared application chrome - Align extension card content - Make extension catalog cards compact - Load marketplace skill details on demand - Publish skills through the extension registry - Make skill authoring visible in Extensions - Preview skill instructions in Extensions - Collapse skill previews by default - Preserve AI response chronology - Stabilize AI model discovery **Full Changelog**: https://github.com/athasdev/athas/compare/v0.11.0...v0.12.0 [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.12.0) ## Editor, extensions, and Git/GitHub improvements (0.11.0) Released: Tue Aug 04 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.11.0) Editor, extensions, and Git/GitHub improvements in Athas 0.11.0. - Update the wrapped Athas Linux release - Align stores with createSelectors and centralize row line-height - Bump quinn-proto from 0.11.14 to 0.11.16 in /crates/database - Add native Codex integration - Add GitHub resource editing workspace - Expand native release packages - Refine project and agent navigation - Clarify pull request submissions - Close Markdown containers before fenced code - Remove unused extension surfaces - Remove obsolete editor infrastructure - Trim unused application APIs - Complete shadcn component library - Add external integration extension runtime - Add GitLab integration extension - Add Sentry integration extension - Keep generated extension manifests stable - Make extension packages cross-platform deterministic - Guard LSP requests by capability and document state - Open Codex resources in native Athas tabs - Preserve OpenRouter streaming responses - Harden Zustand store architecture - Add GitHub notifications menu - Fit multibuffer view toggle to its header **Full Changelog**: https://github.com/athasdev/athas/compare/v0.10.0...v0.11.0 [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.11.0) ## Editor, extensions, and Git/GitHub improvements (0.10.0) Released: Wed Jul 29 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.10.0) Editor, extensions, and Git/GitHub improvements in Athas 0.10.0. - Codify reusable workbench UI conventions - Unify editor and terminal tab interactions - Make fullscreen workbench surfaces edge to edge - Refine Monaco scrolling and sticky chrome - Restore command palette keyboard navigation - Centralize product and service configuration - Pin release workflow toolchains - Persist file-open benchmark traces - Add shared action and avatar primitives - Standardize Git command forms - Refine editor and diff navigation - Simplify GitHub review surfaces - Refresh the Athas theme palette - Unify transparent workbench chrome - Constrain tab dragging to tab axes - Bump serdewith from 3.19.0 to 3.21.0 in /crates/database - Add persistent custom theme tools - Preserve markdown link destinations - Polish editor interaction surfaces - Keep recent editor buffers warm - Upgrade terminal transport compatibility - Add symbol-aware breadcrumb showing containing function/class - Fix symbol breadcrumb pane state - Scope project state by workspace runtime - Remove the Athas editor engine - Move tests into feature-local directories - Make GitHub authentication failures recoverable - Improve GitHub sidebar navigation - Consolidate extension domain ownership - Repair extension workflow paths - Reopen-closed-tab works for images, pdfs, and previews - Remove obsolete brand assets - Add workspace-wide Go to Symbol via # mode in quick-open - Organize repository scripts by workflow - Adopt compound context menus - Keep inline blame aligned with edits - Preserve inline rename cancellation - Improve rendering performance on Windows - Remove UI primitive tests - Enable global file and folder drops - Replace segmented controls with toggle groups - Add Nix flake with dev shell and prebuilt run target - Consolidate tab primitives - Replace split actions with button groups - Adopt the Kbd primitive for shortcuts - Replace the custom Slot with useRender - Add the canonical dropdown menu primitive - Replace the custom loader with Spinner - Keep the UI directory component-only - Polish the update experience - Replace the custom toast primitive with Sonner - Consolidate sidebar feature structure - Move motion presets into shared utilities - Remove obsolete design system directories - Modernize workspace file search - Consolidate dropdown primitives - Merge remote main changes - Complete shared primitive migrations - Consolidate viewer feature ownership - Rebuild the AI chat experience - Standardize shared interface primitives - Refresh the built-in Athas theme - Disable window transparency by default - Reduce workspace file-open contention - Isolate the npx Codex adapter workspace - Format toast option arguments - Refine workspace chrome interactions - Polish the update split control - Use the maintained Codex ACP adapter - Refresh OpenAI model metadata - Unwrap fenced assistant prose - Correct the Ayu Dark palette - Constrain GitHub sidebar rows - Restore command list scrolling - Keep activity rail expansion global - Center collapsed activity rail controls - Render assistant messages without frames - Add copy action to assistant messages - Add user message editing for supported agents - Balance macOS title bar spacing - Isolate Agent sessions across surfaces - Prevent Git blame signature crashes - Sync stable releases to the website - Harden Linux runtime packaging - Expand bundled file icon themes - Standardize shared interface components - Standardize settings layout and typography - Compact the AI composer controls - Stabilize editor workspace sessions - Add project-aware run actions - Overhaul Git data flow and diff handling - Standardize empty states across the app - Update managed Bun and frontend dependencies - Bound extension loading concurrency - Improve project and session workflows - Refine window chrome and workspace navigation - Fix Windows preview release linking - Fix Windows chrome controls - Reveal tab bar actions on hover - Enable Windows window transparency - Fix Windows new window shortcut - Fix Windows Git Bash terminals - Fix git changes file name spacing - Preserve terminal shell profiles - Fix Windows preview integrations - Refactor AI chat composition and state - Standardize application UI foundations **Full Changelog**: https://github.com/athasdev/athas/compare/v0.9.0...v0.10.0 [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.10.0) ## Editor, extensions, and Git/GitHub improvements (0.9.0) Released: Wed Jul 15 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.9.0) Editor, extensions, and Git/GitHub improvements in Athas 0.9.0. - Remove Zig requirement from file search builds - Use native file search across picker surfaces - Position code lens labels after editor text - Add debugger footer context menu - Use solid download icons - Open extensions as an editor tab - Polish extensions tab layout - Surface extension activation actions - Centralize rounded control styling - Normalize shared primitive radii - Polish extensions surface tokens - Use shared GitHub form controls - Normalize GitHub row surfaces - Polish GitHub action viewer controls - Normalize Git surface controls - Polish GitHub header chips - Use split action in Git composer - Tighten Git sidebar controls - Normalize chrome menu surfaces - Add extension activation controls - Normalize AI selector surfaces - Normalize AI context controls - Normalize database viewer surfaces - Normalize SQL database surfaces - Normalize editor status menus - Simplify shared search controls - Normalize notification command rows - Normalize database CRUD buttons - Normalize settings navigation radii - Normalize database sidebar radii - Normalize binary viewer surfaces - Normalize debugger panel radii - Normalize file tree row radii - Add extension activation controls - Normalize settings control surfaces - Normalize Git control radii - Normalize account settings radius - Tighten chrome trigger styling - Normalize remote connection controls - Switch default fonts to Geist - Move telemetry metadata out of settings - Standardize badge styling - Fix sidebar rail layout - Separate activity rail expansion - Move project switcher into activity rail - Recover missing release notes - Refine activity rail controls - Polish activity rail spacing - Stop activity rail from reflowing layout - Keep activity rail in layout flow - Show agent history in activity rail - Keep Athas themes built in - Standardize activity rail rows - Fix Agent message metadata and file links - Add shared application icon adapter - Add Nix language highlighting - Show extension artwork in the catalog - Add rich GitHub sidebar previews - Unify project setup in the picker - Center Agent creation in empty editors - Unify workbench chrome and navigation - Tighten compact UI density - Adopt shared icons across the application - Move chrome controls into shared UI - Move workbench gap into the theme - Standardize UI control typography - Colocate feature-specific UI styles - Remove the conflicting compatibility theme - Centralize typography font stacks - Use the bundled Athas theme palette - Use the standard radius scale - Align font utilities with settings - Use explicit Button sizes - Standardize multibuffer editor surfaces - Make Button borders explicit - Harden global content search paging - Render global search as a multibuffer - Improve translucent sidebar contrast - Restore credential persistence and CI builds - Fix AI chat response handling **Full Changelog**: https://github.com/athasdev/athas/compare/v0.8.2...v0.9.0 [View the release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.9.0) ## Editor, GitHub, and release automation polish (0.8.2) Released: Tue Jul 07 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.8.2) Editor, GitHub, command-surface, Linux runtime, and release automation improvements. ## Editor and language intelligence - Wire Monaco LSP navigation more deeply into editor workflows. - Polish Monaco hover sizing, bounds, and diff navigation behavior. - Tighten editor shortcut handling and preserve undo history for editor commands. - Add Astro language support and expand language extension metadata. - Move Monaco wiring into editor engine modules so editor startup code has a clearer boundary. ## Git, GitHub, and command surfaces - Standardize command picker rows, utility command rows, Git selector surfaces, and shortcut rendering. - Improve GitHub PR viewer actions, sidebar rows, avatar fallbacks, and commit-row behavior. - Clarify Git history sync state and refine inline unpushed indicators. - Tighten Docker, Git, and multi-file diff sidebar chrome. - Add split action button primitives and keep split action buttons fitting narrow layouts. ## Runtime and extensions - Fix Linux CEF graphics fallback behavior. - Move extensions into the sidebar and keep extension surfaces aligned with the newer sidebar layout. - Reduce frontend development logging noise. ## Release automation - Stabilize nightly preview release setup, including Zig installation and tag-based preview builds. - Avoid pushing `main` from nightly previews and increment preview versions from existing tags. - Support the release token secret used by the release workflow. - Select the newest preview tag directly when deciding whether nightly should ship another preview. ## Full changelog See the full generated compare: https://github.com/athasdev/athas/compare/v0.8.1...v0.8.2 ## Performance and UI responsiveness improvements (0.8.1) Released: Thu Jul 02 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.8.1) Render performance, selector narrowing, Git diff responsiveness, and UI subscription cleanup. This release improves render performance across workspace, editor, Git, terminal, search, and settings surfaces by narrowing subscriptions and reducing repeated lookup work. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.8.1 ## Monaco editor and performance overhaul (0.8.0) Released: Sun Jun 14 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.8.0) Monaco editor migration, file tree performance, Git workflows, Docker workspace tools, and app runtime polish. This release moves the editor surface to Monaco, improves file tree and search performance, expands Git and Docker workspace workflows, and polishes app runtime behavior. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.8.0 ## Editor, terminal, and settings refinements (0.7.2) Released: Thu May 28 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.7.2) Editor, terminal, settings, and workflow refinements for the 0.7 line. This release continues the 0.7 line with refinements across editor interactions, terminal behavior, settings, and daily workflow reliability. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.7.2 ## Stability and workflow polish (0.7.1) Released: Wed May 20 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.7.1) Focused editor, workspace, and release polish after the 0.7 release. This release follows up on the 0.7 line with stability and workflow improvements across editor, workspace, and release surfaces. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.7.1 ## Collaboration, database, and workspace foundations (0.7.0) Released: Mon May 18 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.7.0) Collaboration surfaces, database workflows, sidebar primitives, project routing, and editor performance improvements. This release adds collaboration and database workspace foundations, refines sidebar and project surfaces, improves editor performance, and strengthens terminal behavior across pane moves. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.7.0 ## Editor history, Linux packages, and database providers (0.6.0) Released: Thu May 07 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.6.0) Editor undo history, terminal persistence, local PDF loading, database sidecars, and Linux package improvements. This release improves editor undo behavior, terminal persistence, local PDF loading, database provider sidecars, language tooling, and native Linux package builds. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.6.0 ## Release scrollbar hotfix (0.5.1) Released: Tue May 05 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.5.1) A focused scrollbar styling fix for release builds. This hotfix corrects scrollbar styling in release builds. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.5.1 ## Editor, LSP, and Linux runtime improvements (0.5.0) Released: Tue May 05 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.5.0) Editor, LSP, Git, Linux runtime, and workspace improvements from the v0.5 release. ## Editor and LSP improvements - Add Nix syntax highlighting and Zig syntax capture updates. - Render LSP semantic tokens, CodeLens actions, signature help, inlay hints, rename preparation, and workspace edits more reliably. - Fix editor cursor scroll sync, token retargeting, inlay hint alignment, diagnostics cleanup, and stateful buffer eviction. - Wire editor context menu actions and improve editor scroll behavior. ## Git and workspace workflow - Polish stash lists and centralize search matching. - Improve Git sidebar workflows, responsive layout, tree guide rendering, and stash opening behavior. - Add multi-root workspace folder management and preserve terminal sessions across tab moves. - Stabilize workspace lifecycle and project tab behavior. ## Linux and release packaging - Add Linux CEF runtime/build workflow support and runtime paths. - Simplify release packaging, fix Linux tarball verification, and fix Linux release CLI install. - Improve Linux folder picker, IPC fallbacks, microphone error handling, and CEF window behavior. ## UI and extension polish - Refine sidebar activity rail layout and polish editor/chat controls. - Add multi-agent chat controls and move AI account controls to the title bar. - Activate theme extension contributions and improve marketplace category handling. - Add custom autocomplete provider support. ## Full release notes See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.5.0 ## Packaging, language tools, and editor fixes (0.4.7) Released: Tue Apr 28 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.7) Release packaging, managed language tools, editor folding, search, and Linux window fixes. This release tightens the release packaging pipeline, improves managed language tool support, fixes editor folding and search rendering, and addresses Linux window resize behavior. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.4.7 ## Refined Settings (0.4.6) Released: Mon Apr 27 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.6) Settings are now easier to use with new keybindings and small tweaks that will make you feel home. ## Settings feel more complete We got rid of the bloat! Settings now feel closer to a real control center, but it's pretty simple to navigate it. Cleaner rows, better selectors, import and export, appearance controls, sidebar preferences, UI font sizing, and keybinding improvements that are easier to scan and edit. ![Settings panel with refined controls](https://athas.dev/changelog/v0.4.6/settings.png) ## Sticky folders Filtering, row actions, git status, compact folders, visibility controls, drag targets, folder whitespace actions, and sticky parent folders make larger projects feel less noisy and faster to navigate. ![File tree with filtering and compact folders](https://athas.dev/changelog/v0.4.6/file-tree.png) ## Refined agent input Skills now live inside the extensions system. Input is now much cleaner with new controls. Agent activity is folded into a calmer conversation flow instead of filling the screen with internal events. ![Agent conversation with compact controls](https://athas.dev/changelog/v0.4.6/agents.png) ## Editor work feels steadier We fixed a bunch of issues on editor. Selecting now feel better and intuitive. ![Editor workspace with steadier daily workflow](https://athas.dev/changelog/v0.4.6/editor-workflow.png) ## Introducing Worktrees (0.4.5) Released: Sat Apr 11 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.5) ## What's new **Language servers, fully heard**: Type hints drift in beside your variables, parameter help appears the moment you open a paren, and if the server crashes, Athas quietly picks it back up. **Hit the mic**: Talk to the agent instead of typing. **Introducing Worktrees**: A new panel in the Git sidebar, right beside changes and stashes. **Remote, without the detour**: Connect to a remote host and it opens as a project tab — browse, edit, and switch the same way you do locally. **Extended CLI commands**: `athas web`, `athas terminal`, `athas remote`. Three small doors into the editor. ## What we fixed ### Git feels calmer `fetch`, `push`, and `pull` no longer freeze the editor while they run. The git actions menu always stays on screen, the gutter updates smoothly on Linux, and the pull request viewer works on older `gh` CLIs. ### The editor stays out of your way Inline edit has a proper toolbar and a rebindable `Cmd+I`. Shortcut chips everywhere in the app update the moment you change a keybinding. Pane fullscreen stops killing the terminal inside it, and the tab bar is there even when you've closed everything. ### Terminal, less fussy Profiles and shell selection, proper paste, ANSI codes out of tab titles, and `Cmd+W` focusing the right thing. ### Small good things Svelte highlighting. A rebuilt SQLite viewer. A warmer first-run onboarding and an in-app What's New tab after updates. Telemetry off by default. Signed Windows builds with SHA256 checksums alongside every release. ## Thanks @Finesssee, @Lyapsus, and @ChristmasSun— thank you for this cycle. ## Syntax highlighting hotfix (0.4.4) Released: Fri Mar 06 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.4) Syntax highlighting was silently broken in all production builds since v0.4.0. A security hardening change removed the CSP permission needed for WebAssembly, which prevented tree-sitter parsers from loading. This release restores it. ## Problems pane, CLI opening, and model selector redesign (0.4.3) Released: Fri Mar 06 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.3) ### Highlights - New Problems pane that surfaces diagnostics with quick actions — click a warning or error to jump to the source, or apply a code action right from the pane - Open files and folders straight from the terminal with `athas foo.txt` or `athas .`, and deep links via `athas://open` - The AI model selector has been completely redesigned into a single unified dropdown with inline API key and Ollama URL editors, provider icons, and full-width search across all providers - Adjustable UI font size in Settings > Appearance — scales text and icons across the entire interface - You can now create new files with Ctrl+N even when no folder is open ### Improvements - Default AI provider is now Anthropic Claude Sonnet 4.5 - Language extension installs use bundled parser assets instead of fetching from CDN - "Go to File" has been renamed to "Quick Open" everywhere - XML-family files (xml, xsl, xslt, svg, plist) now get syntax highlighting - Sticky line numbers in file preview so they stay visible while scrolling ### Bug Fixes - Language servers now properly activate after installation on Linux - Switching between files no longer causes stale highlighting, wrong cursor positions, or scroll jumps - Syntax highlighting works correctly after updating from older versions (stale cache issue) - File drops work reliably on Windows, and file tree lag on large repos is reduced - Terminal fonts render correctly on Windows with platform-aware fallbacks - GitHub PR menu correctly detects expired tokens instead of showing a cryptic error - Menus close properly when clicking outside on Windows - macOS text replacements now work in the terminal - Diff viewer hunk accordions actually toggle when clicked ## Search, binary previews, and editor refinements (0.4.2) Released: Tue Mar 03 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.2) This release brings syntax-highlighted file previews to global search, a new binary file viewer, accordion-style Git pane sections, and bundled tree-sitter parsers for more reliable syntax highlighting. ### Added - Syntax-highlighted file preview in global search - Binary file viewer with WASM metadata and hex preview - Binary file preview in command bar and global search - SQLite file support in binary preview - SQL language support - Framer-motion animations for dropdowns, modals, and command bar ### Changed - Rename command bar to quick open - Replace Prism with tree-sitter for markdown code block highlighting - Bundle tree-sitter parsers and remove CDN fallback - Rebuild all tree-sitter parsers from source to fix WASM ABI mismatch - Implement accordion layout for Git pane sections - Make stash and history panels mutually exclusive - Remove sidebar search pane in favor of global search dialog - Extract runtime and tools into workspace packages - Replace window zoom with component-level zoom ### Fixed - Fix syntax highlighting for YAML and JSX - Fix Git pane layout: fill available space, reduce gaps, hide scrollbars - Fix file/folder dialog extending beyond screen - Fix release CI failures for Linux builds - Skip AppImage bundling on Linux to fix linuxdeploy failure ## Workflow quality and stability improvements (0.4.1) Released: Mon Mar 02 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.1) This release improves day-to-day editing and Git workflows, strengthens ACP tool/runtime handling, and fixes key edge cases in parser behavior, inline editing, and macOS autofill behavior. ### Added - Manual Git repository selection - Improved ACP tool detection for Go/Cargo-managed runtimes ### Changed - Improved AI chat, workspace, editor tabs, terminal, and Git workflows - Reorganized documentation and merged setup/release guidance into a single Contributing page - Updated docs links (sidebar/footer, install paths, and Edit on GitHub targets) ### Fixed - Parser query compatibility and fallback handling for unsupported predicates - Inline edit and AI message rendering edge cases - File explorer handling for `.DS_Store` files - macOS autofill heuristic handling reliability ## Authentication, AI, and extension platform foundations (0.4.0) Released: Thu Feb 19 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.4.0) ### Added - Add authentication - Add split view editor panes and new tab view - Add planning mode in the AI agent pane - Add runtime language catalog with CDN deploy pipeline - Add .editorconfig integration - Add file copy/cut/paste with cross-window clipboard sharing - Add minimap toggle setting with keyboard shortcut - Add keyboard shortcuts for web viewer - Add find/replace, minimap, and multi-cursor improvements - Add Lua and Rust language support with runtime tooling infrastructure ### Changed - Revamp Git interface and refactor git module internals - Merge TSX into TypeScript extension flow in marketplace and installer - Drive Ruby/ERB detection from extension metadata - Refresh theme system and align terminal and UI styling - Improve AI chat UI and ACP protocol integration - Modularize editor styles into feature-based modules - Move docs to Fumadocs and refresh documentation workflows - Remove bundled language extensions in favor of manifest-driven installs - Remove GitHub Copilot integration ### Fixed - Fix memory leaks, reduce I/O overhead, and improve editor/runtime performance - Fix deploy workflow safe.directory handling and dirty worktree pull behavior - Fix editor view reset when switching to uncached files - Fix tab sync, hover lifecycle, and open-file reliability - Fix language extension installation and update flow - Fix find-in-file navigation and highlight positioning - Fix extension store persistence for installed extensions - Fix app freeze on large commit diffs - Fix terminal toggle keybinding on macOS - Fix viewport behavior with zoom-level adjustments - Fix right sidebar slow open when terminal is active - Fix tokenizer bypass by validating extension installation state - Fix broken links on docs index ### Security - Apply desktop auth and autocomplete security hardening with additional tests ## Release 0.3.2 (0.3.2) Released: Tue Jan 13 2026 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.3.2) ### Added - Native PDF viewer with external open support - CSV viewer as built-in extension - HTML/CSS live preview with asset protocol support - Preview mode for file tabs - Auto-refresh for externally created/deleted files - In-app report a bug button - Drag and drop to open folders as projects and files as buffers - Test connection button and feedback for SSH connections - Configurable command bar file limit and improved fuzzy search - Cmd+hover definition link highlighting - Jump list navigation - Performance monitoring system ### Changed - Virtualize file tree for better performance - Optimize editor rendering - Improve PDF and image zoom controls - Improve autocompletion behavior and LSP completion - Remove Rust from bundled registry ### Fixed - Fix scroll position bugs in editor - Fix file tree git status not updating on save - Fix nvim cursor in normal and insert mode - Fix terminal corruption with multi-byte UTF-8 characters - Fix search highlighting in editor - Fix command palette not finding all files - Prevent command injection in SSH fallback commands - Fix git blame not appearing after file switch - Fix duplicate LSP server creation due to race condition - Fix gap between sticky headers in file tree - Preserve scroll position when switching between buffers - Fix window resize on Linux - Disable problematic DMABUF renderer on Linux - Fix stored XSS in markdown parser by sanitizing HTML output - Bundle FreeType in Linux AppImage for older distro compatibility - Fix incorrect bundled LSP path on Linux - Fix git blame not showing after scrolling - Fix tokenization lag and visual flashing during typing ## Release 0.3.1 (0.3.1) Released: Mon Dec 22 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.3.1) ### Fixed - Fix Windows build by correcting CLI module imports ## Release 0.3.0 (0.3.0) Released: Mon Dec 22 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.3.0) ### Added - Ollama support for local AI models - ACP (Agent Client Protocol) integration with session modes - GitHub pull request integration with checklist rendering - Project picker dialog for workspace management - Web viewer for browsing URLs in editor - Extension system core architecture with bundled extensions - Syntax highlighting in diff viewer - Markdown syntax highlighting - Terminal font settings customization - Advanced model selector dropdown in AI chat - ARIA accessibility descriptors for menus and tabs - Persistent commands feature - SSH key authentication with multiple key fallback - Open File in Editor feature for AI agent - Slider component and Christmas theme - Pre-release check script for validating releases ### Changed - Replace expandable commits with hover previews in source control - Improve LSP integration with diagnostics - Improve scrollbar design - Auto-refresh Source Control when view becomes active - Add 1 second delay before showing git blame popover - Refactor theme system - Extend Gemini API support ### Fixed - Fix LSP popup position - Fix editor viewport and line alignment bugs - Fix terminal font rendering for Nerd Fonts - Fix context menu positioning - Fix sticky folder background transparency in file tree - Fix workspace reset and terminal persistence - Fix drag region for window on macOS - Fix autosave functionality and dirty state logic - Fix traffic lights for macOS 26 - Fix LSP for JavaScript/TypeScript files ## Terminal and extension build fixes (0.2.7) Released: Tue Dec 09 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.2.7) Production build, terminal, extension, keymap, and file explorer fixes. This release fixes production build issues around the terminal and extensions, consolidates keymap command registration, and adds a file explorer action for opening folders. See the full generated release notes on GitHub: https://github.com/athasdev/athas/releases/tag/v0.2.7 ## Release 0.2.6 (0.2.6) Released: Thu Dec 04 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.2.6) ### Added - Auto-update system with GitHub Releases integration - Markdown preview button in editor toolbar - Deep link support (`athas://` protocol) - Linting service with Tauri backend support - Symlink support for file explorer and icon themes - Keymaps feature with customizable keyboard shortcuts - External editor support - Right-click context menu in editor - Code folding in gutter - xAI Grok models support - Gemini 3 Pro Preview support - Settings search functionality - Storybook for UI development and testing ### Changed - Migrate to tree-sitter-web for syntax highlighting - Migrate AI chat history to SQLite - Refactor terminal module and fix auto-create behavior - Refactor AI chat UI - Improve LSP client and configuration - Improve formatter service - Improve extension system with on-demand architecture ### Fixed - Fix editor rendering and extension install UX - Fix command bar not triggering - Fix scrolling issues - Fix Git Blame and other git issues - Fix line numbers not showing up on big files - Fix highlighter initialization after extension installation - Fix HighlightLayer memo bug - Fix editor selections - Fix cursor position restoration and tab switching conflicts ## Release 0.2.4 (0.2.4) Released: Sat Nov 08 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.2.4) ### Added - Project tabs for multi-workspace support ### Changed - Organize files by feature (vertical slice architecture) - Refactor editor and fix overall issues ### Fixed - Fix Windows build errors in CLI and search commands - Fix git status rows for nested paths and stage directories correctly ### Removed - Remove welcome screen and CLI install prompt ## Release 0.2.2 (0.2.2) Released: Thu Oct 30 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.2.2) ### Added - Release automation system - Certificate import and notarization for macOS in GitHub Actions ### Changed - Vim enhancements ## Release 0.2.1 (0.2.1) Released: Wed Oct 29 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.2.1) ### Added - Code signing for macOS - New AI models and BYOK (Bring Your Own Key) settings - Image preview and toolbar - Extension support for syntax highlighting - CLI command installation feature - Setting toggles in command palette ### Changed - Improve UX in switching projects - Make git inline blame popup more compact ### Fixed - Fix welcome screen theme responsiveness for light mode - Fix viewport ref for scrolling - Fix syntax highlighting initialization - Fix intrusive UI on the code editor - Fix traffic light position for macOS ## Release 0.1.2 (0.1.2) Released: Sun Oct 19 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.1.2) ### Added - Markdown preview - Icon themes - Multiple AI agents - Individual zoom for editor, terminal, and window - Vim commands - Shortcut for color theme selector - Shortcut to kill terminal process ### Changed - Improve SQLite viewer - Refactor cursor styles for Vim mode ### Fixed - Fix editor syntax and search highlighting - Fix Vim mode issues - Fix agent dropdowns - Fix editor scrolling ## Release 0.1.1 (0.1.1) Released: Wed Aug 27 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.1.1) ### Added - Git blame functionality with inline display and hover details - Password prompt dialog for SSH connections - Lines and columns information in footer - Integrated menu bar with toggle option - Global search shortcuts - Keyboard shortcuts to text editor - Code formatting feature - Move line up/down functionality - Cursor position restoration when switching files - Highlight search results and click-to-jump - Shell switching support - Close editor tabs with middle click ### Changed - Enhance remote connection handling - Improve text selection handling - Improve command bar performance - Refactor clipboard utilities to use Tauri clipboard manager ### Fixed - Fix Linux menu bar UI - Fix zooming issues - Fix context menu positioning when zoomed - Fix completion dropdown not hiding after acceptance - Fix auto-pairing logic ## Release 0.1.0 (0.1.0) Released: Tue Aug 12 2025 00:00:00 GMT+0000 (Coordinated Universal Time) [Release on GitHub](https://github.com/athasdev/athas/releases/tag/v0.1.0) Initial release --- # Telemetry Source: https://athas.dev/docs/telemetry What Athas sends, what it does not send, and how local telemetry delivery works. Athas keeps telemetry intentionally narrow. Anonymous usage telemetry is **off by default**. If you turn it on, Athas sends anonymous operational metadata so we can understand app health, integration behavior, and crashes. Athas still sends a smaller update-check signal so the updater can work and we can measure release health by version and platform. ## What Athas Always Sends Athas always sends a small update-check payload: - Anonymous install ID stored locally on the device - App version - Platform and CPU architecture - Update-check status such as `available`, `up_to_date`, or `failed` - Available version when an update exists Athas also keeps basic lifecycle context locally, including install date, previous version, and launch count, and attaches that context to telemetry events. ## What Athas Sends When Enabled When anonymous usage telemetry is enabled, Athas may also send: - Heartbeat events from active app sessions - Installed integration IDs and versions during integration sync and update checks - Extension update candidates and update counts - Extension install, uninstall, and update events - Crash reports for runtime failures and unhandled errors ## What telemetry does not send Usage telemetry does **not** send: - File contents - Source code - Prompt contents - Chat messages - Terminal contents - Secret values from your environment - Workspace paths - Full project structure or framework-level product analytics ## How Data Is Sent Athas stores telemetry in a local queue and sends it over HTTPS: - Telemetry initialization starts about 10 seconds after app launch - The queue flushes every 5 minutes - Athas also flushes early when 50 events are waiting - The local queue is capped at 200 events; oldest events are dropped first Crash reports are queued locally too, so Athas can retry delivery on a later launch if a send fails. ## Crash Reporting Crash reporting is part of Athas anonymous usage telemetry. If the desktop runtime hits an unhandled error, Athas records diagnostic metadata such as: - Error message - Stack trace when available - Crash source such as bootstrap failure, window error, or unhandled rejection - App version, platform, and architecture This helps us fix stability issues without collecting project contents. ## Telemetry Log You can inspect recent local telemetry activity inside the app: 1. Open **Settings** 2. Go to **Advanced** 3. Open **Telemetry Log** The log shows queued events, delivery attempts, failures, and clears. You may see entries like: - `queued` - `sent` - `failed` - `dropped` - `cleared` **Info:** Clearing the telemetry log removes local history entries. It does not disable telemetry and it does not delete pending queued events. ## Settings Athas currently exposes a single usage telemetry toggle in **Settings → Advanced**. That toggle covers: - Heartbeats - Extension metadata and lifecycle events - Crash reports Update checks remain operational even when usage telemetry is off. ## Why This Exists Athas uses telemetry for product operations, not deep behavior profiling. The goal is to answer practical questions such as: - Are updates working? - Are integration installs and update checks working? - Are crashes clustered around a specific release or platform? - Are desktop sessions alive after rollout? If that is all working, we do not need heavier analytics. ## Other online features These statements describe telemetry. Choosing hosted AI sends the relevant prompt/context to its service; sharing and cloud session sync upload the content described in [Share to Web](https://athas.dev/docs/sharing). Connected accounts also make service requests. Read [Security](https://athas.dev/security) and each feature guide for its own data boundary rather than applying telemetry exclusions to every online feature. --- # Contributing Source: https://athas.dev/docs/contributing Set up Athas from source, run the required checks, and submit a focused contribution. Athas uses Tauri, React, TypeScript and Rust. Start with a focused issue or reproducible bug and check existing [issues](https://github.com/athasdev/athas/issues) before starting overlapping work. ## Requirements - Git, Rust through [rustup](https://rustup.rs), Node.js 24.19.0 and Bun 1.3.14 for the current repository. - macOS: Xcode Command Line Tools (`xcode-select --install`). - Windows: Visual Studio Build Tools with Desktop development with C++ and WebView2. - Linux: your distribution's native compiler, GTK, WebKitGTK 4.1 and Tauri dependencies. The repository's `package.json`, setup scripts and `AGENTS.md` are authoritative if requirements change between releases. Linux builds use the system WebKitGTK runtime; CEF setup is no longer required. ## Clone and run ```bash git clone https://github.com/athasdev/athas.git cd athas bun setup bun dev ``` `bun setup` installs dependencies and checks platform requirements. On supported Linux distributions it offers the appropriate native dependencies. Read its output before installing system packages. If your environment is already prepared, `bun install` installs JS dependencies. ## Find the right code | Concern | Location | | ------------------------------------ | ----------------------------------------- | | Frontend feature | `src/features//` | | Shared UI primitives | `src/ui/` | | Shared hooks and helpers | `src/hooks/`, `src/utils/` | | Integration and theme implementation | `src/extensions/` | | Rust feature logic | `crates//` | | Desktop wiring | `src-tauri/` | | Public documentation | `athasdev/www`, under `src/content/docs/` | Read `AGENTS.md` before making changes. Follow nearby patterns, reuse existing controls, and keep a feature's components, services, stores and tests together. ## Validate a change ```bash bun check bun typecheck bunx vp test run ``` Run the relevant tests while iterating. For Rust changes, also run `bun check:rust`; a focused `cargo test -p ` can help during development. Verify visible changes in the app with both themes and keyboard navigation where applicable. ## Build Linux packages Run native package builds on Linux after installing its build dependencies: ```bash bun build:linux:deb bun build:linux:rpm bun build:linux:appimage ``` The repository also provides `bun build:linux:tarball` and `bun build:linux:flatpak`. See the current package scripts for output locations and prerequisites. ## Submit a contribution Keep each commit focused, explain the problem and resulting behavior, and include a concise test plan. Add screenshots for visible changes. Review the [Contributor License and Feedback Agreement](https://github.com/athasdev/athas/blob/main/CONTRIBUTOR_LICENSE_AND_FEEDBACK_AGREEMENT.md) before submitting. Athas is licensed under [AGPL-3.0](https://github.com/athasdev/athas/blob/main/LICENSE). For documentation changes in the website repository, follow its own `AGENTS.md` and use Vite+ with Node 24.19.0. Desktop and website validation commands are different. ## Documentation contributions Report an inaccurate guide through its Suggest an edit link. Include the affected version and source behavior so the correction can be verified. [Documentation for LLMs](https://athas.dev/docs/for-llms) describes the generated Markdown exports. --- # Documentation for LLMs Source: https://athas.dev/docs/for-llms Read complete Athas documentation as Markdown, cite source pages, and choose focused context. Athas publishes the same documentation for people and assistants. The Markdown endpoints are public, do not require an account, and preserve commands, tables, platform labels and links. ## Entry points | Resource | URL | Use | | ------------------- | -------------------------------------------------- | ---------------------------------- | | Documentation index | [/llms.txt](https://athas.dev/llms.txt) | Discover guides by topic | | Full documentation | [/llms-full.txt](https://athas.dev/llms-full.txt) | Read the complete guide collection | | One guide | [/docs/llms/installation](https://athas.dev/docs/llms/installation) | Retrieve focused Markdown | | Getting started | [/docs/llms](https://athas.dev/docs/llms) | Read the docs home as Markdown | The index and full export are also available at `/docs/llms.txt` and `/docs/llms-full.txt`. Every guide has a **Markdown** link and a **Copy page** action. Each export includes the canonical human-readable source URL for citations. Internal server runbooks and private account data are not part of this collection. ## Retrieve only what you need ```bash curl -fsSL https://athas.dev/llms.txt curl -fsSL https://athas.dev/docs/llms/cli curl -fsSL https://athas.dev/llms-full.txt -o athas-docs.md ``` Start with the index, then retrieve the specific guides for the task. Full exports are larger and can consume unnecessary context for a narrow question. ## Ground an answer Ask an assistant to cite the source URL, distinguish macOS from Windows/Linux, check the user's Athas version and keymap, and include account or integration requirements where relevant. Do not infer an API, CLI option, permission guarantee or supported capability from a feature name. ```text Read https://athas.dev/docs/llms/installation and https://athas.dev/docs/llms/troubleshooting. Help me diagnose my Linux launch error. Ask for the exact error and package format. Cite the source guide and keep commands specific to my distribution. ``` ## Product docs versus project rules These docs explain Athas. Your repository's `AGENTS.md` and other instruction files explain how an agent should work in your project. See [Agent context and instructions](https://athas.dev/docs/agent-context) for those files and their boundaries. The exports are a convenience for reading and retrieval. Availability does not guarantee that any particular model or search engine consumes them.