Build with Flame

• Open Settings from the gear or command palette, then search across projects, appearance, editor, files, Git, terminal, AI, language servers, extensions, integrations, layout, gestures, updates, logging, and more.
• Use Project Settings for run configurations, session restore, worktree setup and copy rules, code-review instructions, favorite scripts, and project color.
• Use Project Groups for shared settings and launch recipes. Member projects inherit group values by default and can turn inheritance off.

• In Settings → AI → Agent runtimes, choose Claude Code, OpenAI Codex, or Gemini through Google's Antigravity CLI.
• Claude Code and Codex are installed on demand. Antigravity runs Google's installer only after you explicitly choose Install, with the command shown before it runs.
• Use Flame's integrated terminal to complete Claude, ChatGPT, or Google sign-in, then select the runtime and model for a conversation or agent job.

• In Settings → AI, add Anthropic, OpenAI, Gemini, OpenRouter, Ollama, LM Studio, Bedrock, Vertex, or another compatible endpoint for model-powered surfaces.
• Set separate defaults for AI Chat, agent runs, inline completion, and one-shot assistants such as conflict resolution.
• Provider keys are write-only in the UI and protected locally. Local Ollama and LM Studio endpoints can keep model requests on the host.

• Review permission prompts before file writes, terminal commands, browser interactions, or IDE mutations.
• Save rules globally, for a project, or for a conversation when the same decision should apply again; remove a saved rule in Settings when it no longer fits.
• Agent tool activity remains visible, and risk-tiered IDE commands still require confirmation when they mutate or expose sensitive state.

• Add ordered actions to run a package.json script or shell command, open a file, open an embedded or external browser URL, start a test watcher, or send an HTTP request.
• Set a project-relative or absolute working directory and environment variables for the configuration. Mark it Auto run only when it should start once with the session.
• Create several independent configurations such as Frontend, API, and Mock service, or define one on a group so every member project inherits it.

Good to know: Portable configuration export removes every Run Configuration environment map because environment values often contain secrets.

• The versioned JSON bundle includes IDE settings, project and group preferences, groups, commands, browser favorites, file shortcuts, and snippets.
• Provider and browser-profile credentials are excluded, and secret-looking values in URLs, headers, commands, or snippets are redacted.
• Project roots, installed extension files, histories, sessions, and notifications are device state and are not imported.

• Choose a Node runtime, use nvm or nvm-windows, and respect a project's .nvmrc for scripts and tooling.
• Enable, inspect, or restart language servers and configure formatters, linters, indexing exclusions, terminal profiles, and external debug adapters.
• Add GitHub or GitLab integration, task-link reference patterns with predefined regex presets (Jira, Monday.com, GitHub, GitLab, ClickUp, Linear, Trello), custom commands, notification behavior, and update channel only when needed.

• Search projects or filter by All projects, Favorites, Changes, or a project group.
• Read the branch, changed-file count, upstream status, package manager, and project type from each card.
• Open files, search, a folder tab, terminal, or AI chat directly from the project card.

• Pin or favorite important projects and create manual or rule-based groups.
• Rules can match names, paths, branches, project types, package metadata, files, remotes, or uncommitted changes.
• Create an empty, npm, Git, or Python project, start from a template, or clone from Git.

• Create a worktree from a new or existing branch, choose its base and folder, and optionally open it as a project.
• Start AI chat in that checkout or let a new chat create a worktree from its title; selected local files such as .env can be copied in.
• Inspect changes or bring committed and uncommitted work into the current branch, unstaged for review.

Good to know: Dependency installation and task restart when switching worktrees are optional settings and are off by default.

• Combine package.json scripts, shell commands, files, embedded or external browser URLs, test watchers, and HTTP requests.
• Open the exact local preview URL you configure in a Flame internal-browser tab beside the code.
• Running again reuses matching active terminal actions and browser tabs instead of launching duplicates.
• Group inheritance: define launch recipes on a Project Group so all stack repositories inherit the same boot sequence.
• Ask AI to configure: prompt an agent to build and register project launch configurations automatically.

• Switch between List, Details, Grid, and Preview views, then adjust sorting, zoom, hidden files, and folders-first behavior.
• Use breadcrumbs, back and forward history, and Filter this folder… to move through large directories.
• Preview images, video, audio, PDFs, fonts, text, and code without leaving the folder.

• Create, rename, move, copy, paste, and drag files within a project or copy them across projects.
• Flame can update imports during supported moves and can paste real desktop file references into Finder, Explorer, and other apps.
• Delete sends items to Flame's workspace trash, where the file operation can be undone; it does not use the operating system Trash.

• Rotate, flip, crop, and resize raster images with optional aspect-ratio locking.
• Save as PNG, JPEG, or WebP and adjust JPEG or WebP quality before writing the file.
• SVG files open as editable source with a live preview; the visual image editor does not provide SVG layers, filters, or annotation.

• Flame exposes 28 targets: PostgreSQL wire (TimescaleDB, Supabase, Neon, AlloyDB, CockroachDB, YugabyteDB, Amazon Redshift, Greenplum), MySQL wire (MariaDB, TiDB, SingleStore, PlanetScale, OceanBase, StarRocks, Apache Doris), MongoDB wire (FerretDB, Amazon DocumentDB), Redis wire (Valkey, KeyDB, Dragonfly), Microsoft SQL Server, ClickHouse, SQLite, and DuckDB.
• Set host, port, database name, username, password, SSL requirements, or connection URI string.
• For SQLite databases, select a local file path directly from your workspace.
• Test connection status with real-time feedback (disconnected, connecting, connected, or error) before saving.

• Explore database namespaces and schemas in a collapsible tree sidebar.
• Inspect table columns, data types, nullability, default values, and primary key markers.
• View estimated row counts and object kinds (tables, views, collections, and keys).

• Query runner supports SQL syntax for relational databases, BSON/JSON query syntax for MongoDB, and CLI commands for Redis.
• View query duration in milliseconds, total row counts, and paginated data tables.
• Edit supported cell values directly in the result grid; column-oriented or otherwise read-only targets stay read-only.

• Attach table definitions, column types, or failing query error messages to AI chat.
• Let agents generate parameterized SQL, optimize slow queries, or write migration scripts with full context.

• Group containers by repository, project group, or Docker Compose application stack.
• Start, stop, restart, pause, unpause, and remove containers with instant visual status indicators.
• Inspect container configuration JSON, environment variables, image tags, port mappings, and volume mounts.

• View real-time CPU percentage gauge, memory usage and limit, network rx/tx bytes, and block I/O statistics.
• Historical resource utilization sparklines help identify memory leaks or CPU spikes during dev tests.

• Stream live container stdout and stderr with search filtering, auto-scroll, and log download options.
• Exec directly into container interactive shell terminals (sh, bash) as dedicated PTY tabs.
• Pass container logs or execution error messages directly to AI chat for assistance.

• Connect Jira Software (JQL queries & Atlassian Cloud / Data Center), Monday.com (GraphQL board integration), GitHub Issues, GitLab Issues, and ClickUp.
• Token credentials remain safely isolated on the host process and are never written to renderer stores, crash reports, or server dumps.
• Configure per-project board bindings so the Tasks panel automatically focuses on the active project's tracker when opened.

• Toggle between 'Assigned to me' account-wide scope and active project board scope.
• Filter by status category chips: To Do, In Progress, Blocked, and Done.
• Search task keys, titles, summaries, and labels with debounced instant search.
• Sort by last updated date, creation date, priority, status category, task ID, or title in ascending or descending order.

• Click 'Start Agent on Task' on any card to pass task key, summary, description, and comments directly to an AI agent.
• Flame automatically generates sanitized git branch names (e.g. fix/FE-104-update-auth-flow) and optional isolated worktrees.
• Click 'Open Agent Chat' to jump back into the exact AI conversation that worked on or is currently working on the task.
• Open tasks in your external browser with one click when manual editing or tracker update is required.

• Review clear per-connection diagnostics explaining query counts and error hints so an empty panel is never ambiguous.
• Configure background auto-refresh intervals in Settings → Tasks to keep task status synced automatically.

• Navigate, reload, search history, favorite a page, pin the tab to a project, zoom, or open DevTools.
• Switch among Desktop, Tablet, and Mobile sizes or customize the responsive viewport.
• Use browser profiles when pages need separate cookies or custom headers.

Good to know: Flame's internal browser and its capture tools are available in the desktop app, not the plain web build. Browser Bridge is a separate Chrome extension.

• Compare two live panes at Element, Viewport, or Full page scope.
• Measure a pixel mismatch, use an opacity overlay, and inspect a DOM diff in the editor.
• Assign a different browser profile to each side when authentication or headers should differ.

• Ask about this page, stage a Fix an issue report with console errors, or attach a viewport or selected element screenshot.
• The agent can read rendered text, DOM, console logs, load failures, screenshots, and interactable elements from an open browser tab.
• Clicks, typing, navigation, and other page-changing actions require permission; staged browser reports remain reviewable before you send them.

• Install directly from the official Chrome Web Store listing.
• Start Flame IDE, open Settings > Browser Control > Chrome Browser Bridge, and select Create pairing code.
• Open the Flame Browser Bridge extension popup in Chrome, review the data-use disclosure, paste the 6-digit code, and select Pair with Flame.

Good to know: Pairing is loopback-only (127.0.0.1:4317). The code is short-lived and single-use, and the extension receives a dedicated bridge token rather than Flame's host API token.

• List, activate, and navigate tabs; read rendered text or HTML and accessibility-oriented element snapshots; and capture viewport, full-page, or element screenshots.
• Inspect console errors and Chrome DevTools Protocol (CDP) network events, or run approved page JavaScript when deeper debugging is needed.
• Approve trusted mouse and keyboard input, cookie changes, or per-tab request and response header overrides through Flame's normal agent permission prompts.

Good to know: Chrome blocks control of internal and other restricted pages (such as chrome:// URLs). Incognito access is not enabled for the extension.

• Use the extension badge and popup to confirm the bridge is on (ON badge), or choose Pause to detach debugger sessions, remove temporary header rules, and clear captured console and network state.
• Choose Forget to remove the pairing from Chrome, or revoke it from Flame Settings to invalidate the bridge token and clear Flame's in-memory activity trail.
• The passive activity trail can include clicks, focus changes, scrolling, special keys, and input length, but it never captures typed input values.

Good to know: Browser data stays on the loopback connection to the local Flame server. Learn more on the Flame Browser Bridge overview page or read the Flame Browser Bridge privacy policy.

• Split terminals side by side, search output, save reusable commands, mirror a terminal in an editor tab, or open it in a separate window.
• Broadcast one templated command across selected projects in parallel or sequence and review each result.
• Fix with AI stages recent output, the working directory, and changed files; permissioned tools can also read output or run a visible command.

• Test Explorer supports Vitest, Jest, node:test, Pytest, Go test, and Cargo test adapters.
• Run discovered tests and inspect their results without reconstructing the runner command.
• An agent can run selected tests and read results through permissioned IDE tools.

• Set breakpoints; start, continue, pause, stop, step over, step into, or step out.
• Inspect the call stack, scopes, variables, watch expressions, and Debug Console while paused.
• Node uses Flame's built-in Inspector backend; other runtimes need a configured external DAP adapter.

• Move between conflict blocks and accept current, incoming, both, or the base version when available.
• AI resolve proposes a block or file result for review; it does not write or stage the proposal automatically.
• Save a partial resolution at any time, then Mark resolved & stage only after every conflict marker is gone.

• Choose a primary project, optional extra projects, provider and model, and whether to isolate the job in a new worktree.
• Run now, schedule a job, or wait for another job; monitor status, logs, questions, and terminal activity.
• Review and land completed work by merging, pushing, or opening a pull request; opt-in auto-merge can land successful jobs automatically.

• Chats receive active editor context; files, snippets, images, browser pages, and terminal output can be attached deliberately.
• File writes, terminal commands, browser interactions, and IDE mutations follow permission rules and visible tool activity.
• Browser Fix an issue and terminal Fix with AI stage evidence for review; the conflict editor's AI returns a proposal you decide whether to save.

• Server-owned lifecycle: Plan Mode enforces a 4-phase state machine (planning → review → executing → completed) persisted across UI reloads so the review gate cannot be bypassed.
• Strict read-only tool gating: During planning and review, all file writes, shell commands, database mutations, and browser actions are denied regardless of saved permission rules.
• Native Markdown editor tab: The generated plan is saved to disk and automatically opened as a standard editable editor tab for human review and refinement.
• Interactive review card: Approve the plan to unlock write tools and execute the exact edited document, or choose Request Changes to provide feedback for another read-only planning pass.
• Session continuity: Planning and execution stay in the same runtime session, retaining codebase context and indexing without redundant analysis.

Good to know: Plans default to <app-data>/plans/<project>/, or can be stored directly in <project>/plans/ by enabling 'Store plans in the project' in Settings.

• Select built-in predefined regex presets for Jira ([A-Z][A-Z0-9]+-\d+), Monday.com (MON-\d+|#\d+), GitHub Issues (#\d+), GitLab, and ClickUp.
• Optionally override or customize regex capture groups and target URL templates (e.g., https://jira.company.com/browse/$1).
• Detected task keys in commit history, branch names, diff titles, and terminal output are rendered as clickable links and AI agent target triggers.

• Open Remote Access from the phone icon in Flame's status bar and choose Anywhere.
• Scan the short-lived QR code. On the phone, confirm that its six-word computer fingerprint matches the six words in Flame.
• Enter the two-digit number shown on the phone into Flame. The phone remains paired until its expiry or until you revoke it.

Good to know: A QR image alone is not enough to finish pairing: approval requires the two-digit code to be entered by someone at the host.

• Off exposes no remote device access.
• Anywhere keeps the Flame server on loopback while the host dials out. The Secure Relay carries end-to-end encrypted traffic and cannot decrypt workspace content.

• Set or change a device expiry. Pairing codes are single-use, and pending codes expire after three minutes.
• Revoke a device to close its live connections immediately and reject future reconnects.
• Rotate the host identity when you want a clean slate; every paired device must scan and pair again.

• The relay never receives the end-to-end session key or plaintext files, requests, terminal data, Git content, or AI conversation content.
• It can observe that a registered host is online, rotating rendezvous identifiers, connection timing and byte volume, and the two live socket IP addresses while the connection exists.
• The browser client is JavaScript served from connect.flame-ide.com. That delivery origin and its build pipeline are inside Flame's trust boundary; a compromised client delivery path could read plaintext.

• Set FLAME_RELAY_DISABLED=1 to prevent contact with the configured relay and bootstrap origins. This does not disable update checks or optional error reporting.
• Set Remote Access to Off in Flame when you do not need paired-device connections.