Features

Every project. One focused IDE.

Start with every project and worktree in reach. Open folders and assets visually. Then give a permissioned agent the same browser, terminal, test, and Git evidence you see.

Developer workflows

Explore the work behind the feature.

Browse all workflow guides

Log Viewer ↗

Inspect JSON, syslog, Apache, Nginx and application logs in Flame IDE. Filter entries, explore timelines and ask AI about errors.

File Compare ↗

Compare files, code, pasted text and images in Flame IDE. Use split or inline diffs, compare across projects, highlight changed pixels and ask AI about changes.

AI Commit Assistant ↗

Generate AI commit messages, catch leaked API keys before you commit, follow Conventional Commits or your own style, and fix failing Git hooks with AI.

Git Client ↗

A full Git client in Flame IDE: fetch, pull, push, merge main, a commit graph with diffs, branches, tags, stashes, squash, worktrees, submodules and compare.

Integrated Terminal ↗

Flame IDE's terminal: one-click npm scripts, shell profiles, splits, pinned terminals, pop-out windows, a ports list with kill, and CPU and memory alerts.

AI Agent Hooks ↗

Run your own shell commands on AI agent events in Flame IDE: prompt submitted, tool use, waiting for you, validation failed, and more, for every provider.

Python Development ↗

Manage Python environments, use Pyright and Ruff, inspect models, generate type stubs, run Pytest, and profile supported workloads in Flame IDE.

AI Code Review ↗

Review code changes with AI in Flame IDE. Get line-anchored findings, choose the review model, discuss suggestions, and turn an actionable finding into a fix.

Local AI IDE ↗

Connect Ollama, LM Studio, or a compatible model endpoint to Flame IDE. Use local AI with project context, configurable AI surfaces, and your existing tools.

Git Worktree Tutorial ↗

A visual Git worktree tutorial for Flame IDE. Create a branch and checkout, choose what to copy, open the worktree, review its changes, and return to your task.

Node.js Profiler ↗

Profile Node.js in Flame IDE with CPU flame graphs, top functions, source hot lines, and heap snapshot comparisons. Give measured hotspots to an AI agent.

AI Agent Manager ↗

Manage AI coding jobs across projects in Flame IDE. Track running and queued work, answer approvals, inspect changes, and review worktree landing decisions.

AI Agent Work Validation ↗

Validate AI coding agent work in Flame IDE. Run ESLint, tests, builds, and custom checks automatically after the agent finishes, with optional AI fixes before you commit.

AI Agent Plan ↗

Use Plan Mode in Flame IDE to have an AI coding agent propose a plan first. Resolve decisions, check approvals, discuss sections, and approve implementation when ready.

Flutter Development ↗

Develop Flutter apps in Flame IDE with an integrated mobile preview, Android and iOS device selection, hot reload, project terminals, and AI coding agents.

Docker & Compose ↗

Manage Docker containers and Compose apps in Flame IDE. Inspect resource use, read logs, and open container shells alongside your source and project tools.

Dependency Auditor ↗

Inspect dependency versions, outdated packages, duplicates, and vulnerability reports in Flame IDE. Review wanted and latest versions and run scoped updates.

Run Configurations ↗

Create Flame IDE Run Configurations for scripts, shell commands, browser URLs, tests, and HTTP requests, with project or group scope and environment sources.

Local File History ↗

Inspect Git revisions and local file snapshots in Flame IDE. Compare edits and restore an available snapshot without resetting an entire repository.

Flame vs VS Code ↗

Compare project workflows, integrated tools, and extension compatibility.

Projects + worktrees

Move across repos without losing the plot.

Flame is built for work that spans more than one repository. Keep project health visible, run parallel agent tasks in isolated worktrees, and make merge decisions from the same workspace.

  • See branch, change, package, and runtime state across projects.
  • Track running, waiting, scheduled, and approval-blocked agent work.
  • Review merge-blocked tasks and ask AI to propose conflict resolutions before landing.
Search all your projects

Find any file, symbol, or declaration from one place.

Search across repositories or narrow the scope to a project group. Jump to functions, types, and classes with Flame's warm workspace symbol index without waiting for language servers to boot.

  • Portfolio-wide text search: Query every repository in parallel with ripgrep speed, regex, and file globs.
  • Warm workspace symbol index: Go to Symbol across indexed projects for functions, classes, interfaces, and types.
  • Command Palette integration: Type # for workspace symbols across projects, or @ for in-file outline.
  • Cross-repo jump to definition: Open files and symbol declarations in other projects without switching windows.
Run configurations & project settings

Launch the parts of your stack you need, together.

Turn the way you start a project into a named, repeatable recipe. A configuration can run package scripts and shell commands, open files or browser URLs, start a test watcher, or send an HTTP request.

  • Configured previews: Open the exact local URL you define in Flame's internal browser beside your code.
  • Reconciled launches: Reuse matching active terminals and open browser tabs instead of starting the same action twice.
  • Group-level inheritance: Define launch recipes once on a Project Group so all stack repositories share the same boot sequence.
  • Worktree sync & automation: Auto-run setup scripts and copy key local files (like .env) when checking out new worktrees.
Folder viewer

Open any folder as a visual workspace.

Open a directory as a visual workspace when filenames alone are not enough. It is faster for assets, docs, generated output, and any folder you need to understand at a glance.

  • Switch among grid, list, details, and preview layouts.
  • Sort, filter, move, copy, paste, and inspect file information.
  • Show hidden files and undo accidental deletes.
Image editor

Fix the asset without leaving the IDE.

Make the common change where the asset already lives, then save it back to the project or export a new file.

  • Rotate left or right, flip horizontally or vertically, and crop.
  • Resize with linked dimensions and adjust JPEG or WebP quality.
  • Save as PNG, JPEG, or WebP, in place or as a new file.
Database workspace

Inspect, query, and edit across 28 database targets.

Flame includes a built-in Database Workspace to manage connections, explore schemas, run queries, and modify table data without third-party desktop tools.

  • 28 database targets: PostgreSQL, MySQL, MongoDB, and Redis-compatible systems, plus MariaDB, Microsoft SQL Server, ClickHouse, SQLite, and DuckDB.
  • Schema & Data Inspector: Browse tables, views, collections, keys, and columns with live row estimation.
  • Multi-Dialect Query Editor: Syntax highlighting for SQL, JSON document queries, and Redis CLI commands with execution timers.
  • Inline Data Editing: Modify supported table cell values directly in the result grid. Read-only targets stay read-only.
  • AI Agent Context: Attach database schemas, column definitions, or query error messages directly to AI chat.
Containers & Docker

Monitor and control Docker container fleets in place.

Flame integrates Docker container and Compose management directly into the IDE. Control container lifecycles, monitor live performance metrics, read log streams, and exec into container shells without leaving your workspace.

  • Docker & Compose Management: Group containers by project or Compose app, start, stop, restart, pause, or remove containers with instant visual status feedback.
  • Real-Time Stats & Charts: Live CPU, memory, network I/O, and disk I/O resource charts updated in real time.
  • Container Logs & Terminal Exec: Stream container logs and attach interactive shell terminals directly into workspace PTY tabs.
  • Inspect & Volume Exploration: Inspect container and image configurations, network mappings, exposed ports, and volume mounts.
Tasks & Task Tracking

Bridge task trackers into code and hand off tasks directly to AI.

Flame connects Jira, Monday.com, GitHub Issues, GitLab Issues, and ClickUp straight into your workspace. View assigned cards, filter status categories, and prompt AI agents to solve tasks with auto-named git branches in one click.

  • One-Click AI Task Handoff: Select any assigned task card and ask an AI agent to complete the task with an auto-initialized worktree and branch.
  • Multi-Tracker Integration: Query assigned tasks, filter by status, and search across Jira, Monday.com, GitHub, GitLab, and ClickUp.
  • Predefined Task Link Presets: Automatically turn task keys in branches, commits, and diff headers into clickable tracker links.
  • Jump to Active AI Conversation: Instantly jump back into the active AI agent conversation working on a task.
Internal browser + AIDesktop app

Preview and debug inside Flame.

Flame's internal desktop browser keeps a live preview beside your code and turns that page into usable context. Send the internal browser tab to AI instead of translating a visual bug into a long prompt.

  • Ask about the current page or send an issue to fix from the browser menu.
  • Include the page URL, viewport, selected elements, and console logs or errors.
  • With your permission, the agent can inspect, click, type, reload, and verify.
Flame Browser BridgeChrome extension

Connect a real Chrome profile when you choose to.

Browser Bridge is a separate Chrome extension, not Flame's internal browser. Pair it to Flame over your computer's loopback interface with a short-lived, single-use code when an agent needs approved access to tabs in your existing Chrome profile.

Flame Browser Bridge Chrome extension connected status displaying loopback connection and active paired state.
  • Inspect tabs, rendered content, accessibility-oriented elements, screenshots, console errors, and network activity.
  • Approve trusted clicks, typing, navigation, cookie changes, page JavaScript, and per-tab header overrides through Flame.
  • Pause to detach debugger sessions and clear temporary browser state, or forget the pairing entirely.
Tests + AI context

Give the agent the failure, not a paraphrase.

Flame keeps the failing test evidence attached to the work, so AI starts from the exact assertion and project state you are already looking at.

  • Click Fix with AI after a test run leaves failures.
  • Flame attaches failing test names, file locations, messages, and assertion diffs.
  • Uncommitted files are included so the agent checks the most likely cause first.
Remote Access & SSH

Reach the machine that has the code.

Develop on remote hosts and dev machines over SSH. Flame Mobile, available soon for iOS and Android, brings files, Git, chat, todos, activity, and terminals to your phone.

  • SSH Remote Development: Client-server architecture running Flame's daemon on remote hosts with automatic ~/.ssh/config and ProxyJump bastion support.
  • Secure Relay: Secured Access connects the native companion to your workstation through an end-to-end encrypted channel.
  • Deliberate pairing: Scan the QR inside the app, approve its two-digit confirmation on the desktop, and revoke connections at any time.
Built-in proof

Deep tools, close to the code.

Flame keeps specialized workflows available without turning the IDE into a maze.

Search all projects & symbol index

Search across every repository simultaneously with ripgrep speed and jump to declarations with a warm symbol index.

Tasks panel & Task tracking

Connect Jira, Monday.com, GitHub Issues, GitLab Issues, and ClickUp with one-click AI agent handoff.

Database workspace

Inspect schemas, execute SQL/JSON/Redis queries, and edit supported table rows across 28 database targets.

Containers & Docker

Manage Docker containers, Compose apps, real-time CPU/memory charts, and container shell terminals.

Git graph

Read commit lanes, branches, tags, changed files, and code diffs on one interactive canvas.

API client

Let AI agents read your code and create endpoints, then run and inspect the requests beside the response.

Debugger

Pause at breakpoints and inspect variables, watches, call stack, and breakpoints beside the source.

Profiler

Trace CPU flame graphs and hot execution lines with one-click Optimize with agent handoff.

Browser compare

Measure pixel mismatch and DOM differences in side-by-side A, B, and Diff overlay views.

File history

See what the AI agent changed and what you changed on one file timeline, with diffs for every step.

Project settings & Run configurations

Define reusable multi-action launch recipes with custom working directories and environment variables.

File dependencies

Trace project files and dependencies connected to the file you are currently editing.

Language + tool support

Bring the stack you already use.

Web language intelligence is bundled. Native servers and project tools are used when they are installed and detected.

Bundled intelligence

Ready for the web stack

TypeScript / JavaScriptHTML / CSSJSON / YAMLBashPHPVue / Svelte / AstroMarkdown

Native servers

Used when installed

PythonRustGoC / C++JavaC#Kotlin / Swift / DartPowerShell

Database engines & wire protocols

28 supported targets

PostgreSQL (TimescaleDB, Supabase, Neon, AlloyDB, CockroachDB, YugabyteDB, Redshift, Greenplum)MySQL (TiDB, SingleStore, PlanetScale, OceanBase, StarRocks, Apache Doris)MariaDBMongoDB (FerretDB, Amazon DocumentDB)Redis (Valkey, KeyDB, Dragonfly)Microsoft SQL Server / ClickHouseSQLite / DuckDB

Quality and tests

Detected from your project

ESLintBiomeStylelintRuffPrettierVitest / JestNode testPytestGo testCargo test / nextest
Complete capability index

Find the feature for your next task.

Search by task, tool, or language, or choose a workflow category. Desktop features are available now unless marked otherwise; Flame Mobile is available soon.

157 features in 12 categories

Workspace & projectsRun your whole stack at once, without losing your place.18 features

Multi-project discovery

Flame scans your projects root and shows every repo with branch, change count, package manager, and project type at a glance.

Project organization

Search, sort, pin, favorite, hide, and color projects while environment, Docker, CI, package-manager, and change badges keep their state visible.

Create, scaffold & clone

Start an empty folder, npm app, Git repository, Python project, saved template, or clone a remote repository without leaving Flame.

Instant project switcher

Jump between projects from the title bar or command palette while pinned cross-project tabs preserve the context you still need.

Groups & workspaces

Bundle related repos into groups with include and exclude project rules, then filter, search, and broadcast across just that set.

Repository-aware grouping

Group projects by repository, keep project and group settings separate, and carry shared commands, shortcuts, favorites, and launch configuration across a stack.

Scoped file shortcuts

Pin files or folders globally, per group, or per project. Add them from Flame or Explorer/Finder by drag and drop, choose a custom icon, filter them, and detect broken targets.

Smart file filters

20 built-in filters for docs, environment files, config, tests, styling, assets, components, hooks, types, databases, dependencies, CI/CD, Docker, build files, scripts, recent files, and more.

File & folder management

Create, rename, copy, paste, drag, compare, and delete with undo from the tree or an Explorer-style folder tab, including files and folders outside a project.

Live filesystem updates

File watchers refresh trees, open buffers, git state, symbols, diagnostics, and agent-written files when something changes inside or outside Flame.

Sessions & restore

Save and restore tabs, layout, and terminal sessions, with an opt-in restore prompt when Flame starts.

Local snapshots

Automatic per-file edit history on save, format, and before risky git operations, independent of commits.

My Activity dashboard

See commits, branches, project activity, active time, CI state, and agent work across your workspace in a standup-ready view.

Run configurations

Define multi-action launch recipes (scripts, commands, files, test watch, and browser URLs) that boot servers and open browser previews automatically without manual port searching.

Todos & reminders

Keep global and project todos in a dedicated side panel or dashboard checklist, add multiline details and local-time reminders, dictate text, undo deletions, and prepare a fresh chat with Do with AI.

Templates & onboarding

Save reusable starter files and setup commands, create a repository from that template, and follow the guided product tour.

Time, clocks & wellness

Track idle-gated active time per project, keep world clocks visible, and use configurable focus timers, breaks, and wellness reminders.

Notification center

Keep a deduplicated, project-filtered history of app, terminal, git, file, search, agent, and CI events, with optional native desktop alerts that lead back to the source.

AI & agentsDelegate real work and stay in control.22 features

Agents Manager

Create, monitor, stop, retry, schedule, and review AI tasks across projects, with a workspace-wide concurrency limit.

Agent hooks ↗

Run your own shell commands on agent lifecycle events such as prompt submitted, tool use, waiting for you, and validation failed, at global, group, or project scope.

Native delegated workers

In supported Claude sessions, enable Multi-agent mode for read-only research and review workers while the lead owns edits and commands. Inspect recorded Claude and Copilot worker activity; support depends on runtime capabilities.

Chat history transfer

Import supported Claude Code, Codex, Copilot, Claude and ChatGPT exports, or a Flame chat archive. Preview and select histories, map them to projects, and export selected conversations without changing source histories.

AI chat in context

Work with selected files, diffs, terminal output, test results, and browser state under scoped, revocable permissions.

Conversation forks

Fork from a message into an independent chat or editor tab, navigate its parent and related forks, and retain the original conversation. Forking keeps checkout context; choose a worktree separately for file isolation.

Usage-limit continuation

Schedule a usage-limited turn to continue when access resets or at a chosen local time. Pending schedules persist across restarts; the backend must be running, and uncertain in-flight sends pause for review.

Multiple & global chats

Keep several conversations open as tabs, start a project-free chat when appropriate, search models, rename or auto-title chats, and clear or archive the context you no longer need.

Choose where each chat works

Run a chat or a task on the current branch, a new branch, any other branch, or its own Git worktree, and move a running chat between checkouts or projects.

Send later or after all chats

Queue or steer while the agent works, schedule a message for a date and time, or send it once every chat in the project is idle.

Images & prompt polish

Paste or drop images into chat, attach curated project context, and improve a prompt with reviewable grammar, clarity, and rewrite suggestions before sending.

Choose your agent

Run Claude Code, OpenAI Codex, or Gemini through Google Antigravity as a full coding agent, and use GitHub Copilot in AI Chat. Switch models per conversation.

Bring your model

Use a local model through Ollama or LM Studio, or connect Anthropic, OpenAI, Gemini, OpenRouter, Bedrock, Vertex, or another compatible endpoint.

Local voice control

Use local Whisper transcription to dictate prompts and trigger supported navigation or agent intents.

Inline completion & next-edit

Fill-in-the-middle completions and Cursor-style next-edit predictions, grounded in your project's symbols.

Focused AI actions

Hand off a failing test, terminal error, API response, diff, review finding, merge conflict, profiler hotspot, or project configuration from the surface where it appears.

Models per assistant

Pick the provider and model for Generate commit message, Summary with AI, Improve writing, Is this safe?, and Help me decide separately from chat.

Queued & dependent work

Schedule an agent for a specific time, wait for another job or an idle conversation, and chain dependent tasks while retaining each job's status, token, duration, and tool history.

Internal browser-to-agent handoff

Send a page, selected elements, screenshots, DOM state, and console messages from Flame's internal browser straight into an AI conversation.

IDE control with confirmation

Let an agent navigate and invoke registered IDE commands through a risk-tiered bridge that confirms mutating or sensitive actions.

Interactive Plan Mode

Enforce a server-owned planning and review lifecycle (planning → review → executing → completed). Read-only tool gates let agents prepare a plan you review in the Plan tab, with decisions, recommendations, and an architecture diagram, before you approve execution.

Structured questions

When an agent needs a decision mid-run, it can ask a structured question and continue from your answer.

Git, branches & worktreesParallel work, made calm.19 features

Branches & worktrees

Create, check out, and manage git worktrees so multiple branches live side by side, with no stashing or context loss.

Update filtered projects

Pull upstream changes across the current project selection using fast-forward-only updates. Dirty, conflicted, diverged, or otherwise unsafe repositories are skipped and reported individually.

Bring uncommitted changes

Optionally copy staged, unstaged, and untracked changes into a new worktree as unstaged files while preserving the source checkout. Review conflicts before continuing.

Worktree cleanup

Identify Missing or Prunable checkout registrations and prune stale Git entries while preserving branches and remaining files.

Worktree handoff

Create an isolated worktree with selected untracked files, switch into it live, or bring finished changes back to another checkout when the work is ready.

Changes & staging

Stage hunks, discard, stash, and open side-by-side diffs straight from the Changes panel with live status badges. Track files, line deltas, and size on disk, with nested changes grouped by folder and unsaved tabs flagged.

Commit assistance ↗

Generate an editable commit message with AI in Conventional Commits, Task-first, Linux-kernel, Semantic, or your own custom convention, checked as you type, and review staged and unstaged changes before committing.

Pre-commit hook fixes ↗

When a pre-commit or commit-msg hook blocks a commit, see which hook failed and why, then stage its output in a chat with Fix with AI.

Compare anything ↗

Diff working files against HEAD, compare arbitrary refs, compare project files, external files, and pasted text, or compare two images side by side or with a slider and highlighted pixel differences.

AI conflict resolution

Open every conflict in a dedicated resolver, or ask an agent to propose a resolution for you to review, stage, and test.

Blame, history & graph ↗

Inline blame, per-file history, searchable commit cards with keyboard navigation, a visual commit graph in a full tab with per-commit diffs, and squash from the UI.

Issue links

Turn issue keys in branch names and commit history into links using predefined regex presets (Jira, Monday.com, GitHub, GitLab, ClickUp, Linear, Trello) or custom expressions that open in the built-in browser or your system browser.

Secret safeguards ↗

Mask sensitive environment values until revealed and flag likely credentials, such as API keys, tokens, private keys, and credential URLs, in changed lines before a commit or push carries them away.

GitHub & GitLab CI

Inspect pipelines and request checks, open per-job log tabs, refresh output, and use supported job actions. GitLab logs retain stage grouping; bounded log tails link to the provider for full output.

Merge queue

Review completed worktree tasks, resolve blocked conflicts, and choose local merge, branch push, or push and prepare PR/MR. Submit the prepared request on the provider.

Review threads

Run an AI code review and keep durable, line-anchored conversations directly inside the diff.

Submodule management

Inspect nested repository state, initialize or sync submodules, browse them, and stage pointer updates with the right context.

Git lock recovery

Detect stale repository lock files and offer a deliberate recovery path instead of leaving Git operations mysteriously blocked.

Terminal & broadcastOne command, every project.13 features

Integrated terminals ↗

Real PTYs via xterm.js: multiple terminals, ANSI output, hyperlinks, search, and persistent session state.

Structured log viewer ↗

Parse JSON, syslog, Apache, Nginx, and application logs from files, pasted text, Docker, or terminals. Filter severity, fields, and time; inspect raw text, mask secrets, and export matching entries.

Split, mirror & move terminals

Tile terminals side by side, move a PTY into an editor tab, mirror it in two places, or detach it to a native pop-out window without restarting the process.

Shell profiles

Choose and configure the shell Flame launches on each platform, with project working directories and runtime-aware environment handling.

Command-aware terminal

Keep the latest command visible while output scrolls, open detected file and web links, search the buffer, and move through terminal history from the keyboard.

Broadcast terminal

Run one command across many projects, a group, or all engaged worktrees at once, with live-sync input and a status matrix.

Broadcast safety & retry

Guard dangerous broadcast commands, see which targets failed, and retry only the failed projects instead of rerunning the entire fan-out.

Script runner

Every package.json script with one-click Run or Debug, plus token substitution like {pm}, {branch}, and {script:name}.

Pop-out & ports ↗

Detach a terminal to its own window, list every listening port with its process, PID, and owning project, open it in a browser, or stop the process holding it.

CPU & memory monitor ↗

See CPU and memory for Flame, language servers, agents, and every terminal in the Resources tab, and get a badge and notification when a terminal passes your memory or sustained CPU threshold.

Tasks & run sessions

Launch project and group tasks, track every active process in one sessions view, and stop or restart workloads without hunting for terminals.

Terminal autocomplete

Get history-, file-, script-, git-, and PATH-aware suggestions while keeping native shell completion available.

Saved & custom commands

Keep frequently used commands at global, group, or project scope, including custom push commands and reusable broadcast presets.

EditorA modern editor tuned for focus and speed.20 features

Code editor

Monaco editing with syntax highlighting, IntelliSense, multi-cursor, folding, sticky scroll, minimap, and project-aware search.

Multi-tab + diff

Pin, reorder, and split tabs. Side-by-side or inline diffs for any file, ref, or pasted content.

Flexible editor layouts

Arrange tabs in single, two- or three-column, two-row, 2x2, or main-and-side grids, then save your own layout for reuse.

Preview tabs & navigation history

Single-click into a reusable preview tab, promote what matters, move backward or forward through locations, and reopen a recently closed tab.

Vim mode & Emmet

Vim keybindings and Emmet expansion, with auto-closing tags and bracket-pair colouring.

Breadcrumbs & outline

Navigate by symbol with a live outline, breadcrumbs, and go-to-definition / find-all-references powered by LSP.

Rich file previews

Preview images, video, audio, PDF, fonts, CSV/Excel, archives, Markdown, and Jupyter notebooks without switching apps.

AI asset editing

Stage an image or SVG with Ask AI, describe the change, and inspect the result in the ordinary editor. Keep edits undoable and export a new sibling asset when you want to retain the source.

Image editor

Rotate, flip, crop, resize, and adjust raster images. Ask AI for asset edits, inspect the result, undo or save it, and export PNG, JPEG, WebP, or AVIF copies.

Markdown & HTML workbench

Switch between source, rendered preview, or a resizable split view. Search and zoom previews, keep scroll position, render Mermaid, toggle Markdown task-list checkboxes directly, navigate long documents with a resizable table of contents, and choose the default HTML view mode.

Safe large & binary files

Detect binary and oversized files before loading them into the editor, stream large text deliberately, inspect archives, and open files in the system app when that is the better tool.

Save All & file recovery

Save every dirty editor in one action, reload files changed on disk, and recover a recently closed tab without losing the rest of the workspace.

Editor tabs in new windows

Move supported tabs into a separate desktop window when a second monitor or focused reference view is more useful than another split.

Project-aware editing

Honor .editorconfig, choose autosave behavior and Markdown view modes, and use auto-detected Prettier or Biome formatting on save or paste.

Refactoring & code actions

Rename symbols across files, apply quick fixes, organize imports, and preview multi-file edits before they touch disk.

References & hierarchies

Inspect references, implementations, document symbols, and incoming or outgoing call hierarchies without leaving the editor.

Snippets & spell checking

Manage scoped snippets, import VS Code snippet files, and catch spelling mistakes with a built-in code-aware offline checker.

package.json intelligence

See script run and debug actions, dependency version context, and package-aware hovers directly inside package.json.

Schema-aware configuration

Resolve built-in, project-local, and declared JSON schemas for completions and validation, including configuration files that do not ship their own schema metadata.

Style usage intelligence

Trace style references across markup and code, surface unused style symbols, and navigate between a class and the places that consume it.

Intelligence & toolingUnderstand, debug, and trust your code.16 features

Debugger (DAP)

Breakpoints, stepping, variables, watches, inline values, call stacks, and a debug console over the Debug Adapter Protocol.

Multi-session debugging

Run more than one debug session, follow spawned child processes, and keep session-specific threads, stacks, variables, and console output organized.

Tests & coverage

Discover, run, and watch Vitest, Jest, Node test, Pytest, Go test, and Cargo test, with grouped results, coverage gutters, and an AI fix action.

Workspace search

Search text, regular expressions, filenames, or symbols across one file, project, selected projects, groups, or the whole workspace with language and symbol-kind filters and recent search history.

Dependency diagram

A project-level file-dependency graph with indexed symbol counts and external package links.

Built-in API client

Run REST and GraphQL requests with scoped environments, cookies, variables, collections, and server-side execution.

API auth & request bodies

Compose Basic, Bearer, API-key, OAuth 2, JWT, or custom-header auth and JSON, raw, XML, multipart, URL-encoded, binary, or GraphQL bodies.

API history & comparison

Inspect request history, rerun or save a prior call, and compare responses without rebuilding the request by hand.

API import & auto-build

Import cURL, OpenAPI, HAR, or Flame collections, or ask an agent to discover the codebase's API surface and build requests for you.

Dependency manager

Inspect outdated, duplicated, or vulnerable packages across npm, Cargo, pip, Go, Composer, Bundler, Maven, and Gradle projects, then filter updates by impact.

Jupyter kernels

Run notebooks with real kernels (Python, R, Julia, and more) with per-cell output.

Problems & diagnostics

Errors, warnings, and hints from language servers and linters, grouped and jump-to-line.

Language-tool controls

See language-server state, restart a server, inspect output, run formatters and source actions, and control code indexing per project.

Tasks, output & problem matchers

Capture build, lint, test, and script output in dedicated views, match diagnostic lines back to source, and restart or stop tracked tasks from one sessions surface.

Node CPU & heap profiler

From Flame's built-in Node debug engine, record interactive CPU flame graphs, mark hot source lines, capture heap snapshots, and compare allocations.

Environment & process insight

Inspect runtime environment, detected toolchains, active processes, ports, and project health from the workspace.

Preview, extend & connectMeet the rest of your workflow.16 features

Live preview & internal browser

Preview HTML and Markdown as you edit, or use Flame's internal desktop browser with device profiles, DevTools, console evidence, and agent-ready page context.

Internal browser workflow

Inside Flame, keep scoped favorite URLs and local history, switch between custom desktop, tablet, and phone profiles, open DevTools, and use keychain-backed password autofill.

Internal browser profiles & routing

Choose an internal browser profile, zoom and emulate devices, autocomplete URLs, or route a page to Flame's internal browser, the default system browser, or a configured external browser.

Flame Browser Bridge Chrome extension

Separately pair Chrome 116+ to the local Flame IDE with a short-lived code when permission-gated agents need to inspect, debug, or control tabs in your real Chrome profile.

Local extensions

Install, validate, enable, and disable manifest-based extensions that contribute languages, snippets, themes, formatters, and linters.

Remote Access

Pair the native Flame Mobile app, available soon, with a short-lived QR code and a host-confirmed two-digit code through Flame Secure Relay.

End-to-end encrypted relay

Secured Access keeps the workspace server on loopback while the host dials out through a content-blind relay. The relay carries ciphertext and connection metadata, but never receives the session key or plaintext user content.

Paired-device control

Give each remote device an expiry, revoke it immediately, close its live connections, or rotate the host identity to unpair every device at once.

Themes & customization

35 built-in light and dark themes, full palette and flame-colour control, density, keyboard shortcuts, and mouse gestures.

Aurora appearance

Turn on an optional Aurora backdrop with see-through panels, named palettes, per-colour overrides, intensity, and motion that respects reduced-motion settings, or keep the classic flat look.

Adaptive panels & gestures

Resize or auto-reveal each side and bottom panel, choose compact layouts, and bind mouse or touchpad gestures to navigation and IDE actions.

Native drag & clipboard

Copy and drag real files between Flame and Finder, Explorer, Slack, or Mail in the desktop build.

Internal browser comparison

Load two pages side by side inside Flame, compare DOM output, and generate pixel-level visual diffs with a configurable mismatch threshold.

Portable configuration

Export and import a versioned, scrubbed JSON bundle of IDE settings, themes, shortcuts, snippets, groups, and project configuration. Credentials, project roots, histories, and run-configuration environment maps stay out.

Local-first safeguards

Keep filesystem, git, terminal, and index work local by default, protect stored credentials, authenticate local connections, and scope agent permissions by action and project.

Desktop updates

Check for stable or pre-release updates, follow download progress, and restart to apply a staged desktop update.

Tasks & task trackingBridge your task tracker directly into code and AI agent workflows.8 features

Multi-provider integration

Connect Jira, Monday.com, GitHub Issues, GitLab Issues, and ClickUp accounts to inspect assigned tasks. Linear and Trello have reference-link presets, not connected task-provider adapters.

Predefined regex patterns

Select built-in task reference regex presets for Jira (PROJ-123), Monday.com (MON-123, #104), GitHub (#123), GitLab, ClickUp, Linear, and Trello to parse task keys instantly in branches, commits, diffs, and terminal output.

Project & account scopes

View tasks assigned to you across connected accounts, or scope the view to the active project's bound board or repository.

Live search & status filtering

Filter by status category (To Do, In Progress, Blocked, Done), toggle assigned to me, and sort by last updated, creation date, priority, or task ID.

One-click AI Agent handoff

Launch an AI agent task directly on a task, automatically generating sanitized branch names like fix/JIRA-123-task-summary.

Jump to active conversation

Jump straight back into the AI agent chat conversation that is actively working or previously worked on a task.

Diagnostic insights & auto-refresh

Explain empty list states with per-connection diagnostics and set background auto-refresh intervals.

Local token security

Manage authentication tokens securely on the host process without exposing credentials to renderer dumps or crash reports.

Desktop, settings & reliabilityShape the IDE around your habits, and keep it dependable.10 features

Multiple Flame windows

Open a new Flame window, open files and folders from the native desktop menu, and place pop-out terminals or editor tabs on another display.

Keymaps that transfer

Switch between Flame, VS Code, JetBrains, and Vim presets, import VS Code keybindings or settings and JetBrains keymap XML, record bindings, and catch conflicts.

Searchable settings

Search settings across projects, appearance, editor, files, search, Git, issues, terminal, voice, debugger, language servers, AI, extensions, integrations, layout, gestures, updates, and more.

Quick settings menu

Hover or focus the title bar settings button for shortcuts to common settings categories, with full keyboard navigation.

Node runtime management

Select the Node runtime Flame uses, integrate with nvm or nvm-windows, and respect project .nvmrc choices for scripts and tooling.

Logs & diagnostics

Choose logging detail, inspect Flame's logs from settings or the native Help menu, and use the output surfaces to diagnose tooling and connection problems.

Connection recovery

Detect when the local Flame server becomes unreachable, show reconnect state, retry health checks, and restore live file, test, debug, LSP, and agent connections.

In-app feedback

Report a bug or request a feature from the IDE with a product area, structured details, and optional diagnostic context.

Guided onboarding

Learn the project switcher, files, editor, terminal, Git, tests, browser, AI, and workspace controls through an in-product spotlight tour.

Accessibility & input choice

Use keyboard-first navigation, visible focus and semantic controls, adjustable density and motion, mouse and touchpad gestures, or voice input according to your workflow.

Python developmentKeep interpreter, tests, types, and application data in the same development loop.5 features

Project Python environments

Discover virtualenv, Conda, Poetry, Pipenv, system, and custom interpreters; select one per project, create environments with uv or venv, and install supported isolated runtimes.

Type stubs and model inspection

Generate .pyi stubs for supported targets, inspect Pydantic and dataclass-style model fields, read generated schemas, and validate sample JSON payloads.

Pytest and fixtures

Run tests through the Pytest adapter, inspect parameterized cases and fixture relationships, and show coverage when compatible coverage tooling supplies the data.

Python CPU and memory profiling

Use the Python profiling path with py-spy or a cProfile fallback and supported memory tooling such as memray. Host tool availability, platform, and permissions determine the available modes.

Python debugging and notebooks

Configure Python debugging through debugpy, inspect supported asyncio task state, and run notebooks with an installed Jupyter kernel.

Dashboard widgets & personal workShape My Activity around the information and actions you use every day.5 features

Custom widget canvas

Add searchable Statistics, Activity, Productivity, and IDE widgets. Reorder cards with drag grips or move buttons, resize with pointer or keyboard handles, align rows, and tune gaps and spacers.

Global & project dashboards

Keep a separate saved layout for the workspace and each project. View work activity, Git history, branches, focused time, agents, tasks, and AI summaries with page-level and per-widget filters.

Actions where you need them

Launch scripts and run configurations, run a custom or saved command in a fresh terminal, start an AI chat, or open text, regex, filename, and symbol search from widgets.

Portable layouts

Export and import validated JSON layouts, copy a layout between scopes, and apply one to other projects. Widget settings and notes transfer; todos retain their original project or global scope.

Edit with a way back

Done keeps the arrangement, Cancel restores the whole edit session, and Restore defaults returns to a starter after confirmation. Customized and intentionally empty layouts are preserved during starter upgrades.

Mobile development & companionBuild beside a device, then stay connected to your workstation.5 features

Mobile Preview panel

Preview Android devices and macOS iOS simulators in a full-height panel beside your code, with device favorites, virtual-device startup, device logs, and supported framework launch actions.

Virtual-device setup

Search the Android model catalog, create emulator targets with SDK and system-image checks, cold boot virtual devices, or configure iOS simulators on a Mac with Xcode.

Device context for AI

Stage a device screenshot and optional recent logs with Ask AI or Add context → Add mobile preview. Review and send the prepared chat; attachments retain the selected device ID.

Flutter iteration

Use the preview target in the Flutter status bar picker, launch a run, and trigger hot reload. Custom launch commands stay available in project terminals.

Flame Mobile · Available soon

A native iOS and Android companion for AI chat, permission decisions, Git, files, terminal, tasks, and shared todos through an encrypted connection to your running workstation.

Feedback

Missing something? Help shape it.

Flame is designed around real developer workflows. Tell us what would make yours better.

Many projects. One coherent workspace.

Download Flame and build with the whole context in reach.

Free to use on macOS 13 (Ventura) or later, Windows, and Linux.