Everything LingCode can do

Native app & performance

• 100% Swift / SwiftUI — no Electron, no embedded browser shell.
• Fast startup & low idle memory — tuned for Apple Silicon and Intel.
• Metal-backed UI — smooth scrolling and editing.
• English & Chinese UI — switch in Settings.

AI & providers

• Multiple cloud providers — use your own keys with OpenAI, Anthropic, DeepSeek, Kimi (global or China), Google Gemini, Alibaba Qwen, and more.
• Ollama & offline — run local models when you want code and prompts to stay on-device.
• Local vs cloud indicator — see whether the active model is local or remote.
• Eco mode + Low Battery auto-switch — LingCode detects when your Mac is on battery power and can automatically route AI calls to a local Ollama model instead of a cloud API. Saves battery on flights and coffee shops, saves API credits too. Configure in Settings → AI; also triggers on full offline mode.
• Per-task model routing — different local models for different jobs: DeepSeek Coder for autocomplete, Qwen for inline edits and refactors, Phi-3 for debug validation. Transparent hybrid: cloud-first with local fallback if network fails mid-request.
• Project-aware chat — semantic search, file and folder context, streaming replies.
• Plan mode — outline tasks and tradeoffs before large edits; pairs with Agent mode when you want a plan-then-execute flow in the same panel.
• Agent mode (60+ native Swift tools) — a tool registry that exceeds Claude Code parity: file ops, search, bash, LSP, build/run, diagnostics, worktree isolation, MCP, and more. Multi-step agent with structured memory, 3-stage context compaction, system prompt caching, and 4 permission modes. Approve or deny actions; full session history.
• AI inline completions (FIM) — Copilot-style muted gray “ghost” text after a typing pause, against your cloud or local model. Uses Fill-in-Middle prompting so the completion is aware of both what you’ve typed and what follows the cursor, not just prefix context. Tab to accept, Escape to dismiss. Enable/disable per workspace in Settings → AI autocomplete.
• Inline edit & diff review — propose edits with preview before apply.
• Context mentions — @file, @folder, @codebase, @selection, @terminal, @web, @docs, @notepad, and related shortcuts.
• Skills / slash commands — large set of / commands for review, explain, commit, security, batch ops, and more. Blog & skills guide

Agent tool surface

60+ tools, all written in native Swift and executed in-process — no subprocess, no RPC. The agent calls the same services the UI buttons call.

• Files — read_file, write_file, search_replace, read_directory, notebook_edit.
• Search — codebase_search (Tree-Sitter indexed), glob, grep (ripgrep).
• Terminal — run_terminal_command, bash_output, kill_shell (background shells supported).
• Build & run — run_build, run_simulator, stop_run, run_tests, run_clean. Same actions as ⌘B / ⌘R / ⌘. / ⌘U / ⌘⇧K.
• Diagnostics — get_build_errors, get_diagnostics, get_run_console_tail, lsp (goToDefinition, findReferences, hover, documentSymbol).
• Editor & project — open_file, get_active_file, get_project_info, get_project_files, list_destinations, set_destination, set_theme, open_settings.
• Workflow — todo_write, enter_plan_mode, exit_plan_mode, enter_worktree, exit_worktree.
• Interaction — ask_user (blocking), send_message (non-blocking progress updates).
• MCP — list_mcp_resources, read_mcp_resource, mcp_tool_call. Your MCP servers' tools show up alongside the natives.
• Web — search_web, web_fetch (HTML → Markdown with size and timeout limits).

Claude Code & terminal workflows (Mac)

• Multiple Claude Code sessions — run several Claude Code editor tabs at once; each session is separate. Conversations persist across quit/relaunch. Claude sessions guide
• Two flavours per agent — CLI variant (wraps the real claude / codex binary in a PTY; every CLI slash command and !bash prefix works) and Native variant (SDK bridge with rendered chat bubbles, cost tracking, and file mention chips). Pick one per tab via the AI menu in the toolbar.
• Click-to-switch model (Native tab) — click the sonnet/opus/haiku badge at the top of a Claude Code Native tab to change models mid-session. Choice persists across launches; the next message uses the new model without restarting the session.
• @file mentions — type @ in the Native tab input to pop a fuzzy file picker scoped to the workspace. Pick a file and it’s attached as context; skips the intermediate “what kind of mention” step.
• Integrated terminal — real PTY terminal (SwiftTerm-backed on Mac) for CLI workflows alongside the editor. Light and dark themes with a dedicated ANSI colour palette for each.
• Codex & other CLIs — run supported CLIs in dedicated terminal integrations where included in the build.
• Custom binary path — if claude or codex is installed at a non-standard location, set the path in Settings → Tools & MCP. The IDE shows clear diagnostics with searched paths and fix instructions when the binary is not found.

Work protection

AI edits can silently break an Xcode project. LingCode assumes they will, and makes every change reversible before you have to notice.

• Pre-edit snapshots — before the agent touches project-critical files (project.pbxproj, Info.plist, *.entitlements, *.xcscheme), LingCode copies the originals to ~/Library/Application Support/LingCode/WorkProtection/. A recovery panel lists them with previews and one-click restore.
• Per-file diff banners — every AI edit appears as a diff card on the file with syntax-highlighted hunks. Keep or revert each hunk independently, not all-or-nothing.
• Semantic time-travel undo — a separate, multi-file undo stack for AI operations, independent of the editor's native undo. Rewind a cross-file refactor in one step instead of undoing each buffer in turn.
• Worktree isolation — enter_worktree / exit_worktree let the agent work in an isolated git worktree for risky experiments. Merge, discard, or keep the branch when done.
• Read-before-write enforcement — the agent cannot edit a file it hasn't read first, preventing "blind overwrite" bugs.

Editor & codebase (Mac)

• Split editor — horizontal and vertical splits.
• Minimap & symbol outline — navigate large files quickly.
• Syntax highlighting — Tree-sitter and Swift-syntax–based highlighting.
• LSP IntelliSense — completion dropdown filtered by what you typed (prefix / filterText), replaces the partial identifier on accept, anchored near the caret. List hides when idle, when there are no results, and is suppressed on empty lines or right after a semicolon (so you don’t get unrelated globals). Also: go to definition, diagnostics, and other language features via configurable LSP servers.
• Global & in-file search — find across the project or in the current buffer.
• Problems panel — diagnostics and build/lint feedback.
• Git panel — status, stage, commit, branches, stash, and related actions.
• Refactoring & quick actions — structured refactors and command-driven edits where available.

Vim-style modal editing (Mac)

Enable Vim keybindings in Settings → Editor for full modal editing without leaving the native editor.

• Modes — Normal, Insert, Visual (character & line), and Ex (:) modes. Current mode shown as a colored badge (NORMAL / INSERT / VISUAL / V-LINE) in the status bar.
• Motion & navigation — h j k l, w b e (word), 0 ^ $ (line), gg / G (document start/end), % (jump to matching bracket).
• Operators + motions — d, c, y combined with any motion or text object (dw, ciw, ya", etc.). Double operators: dd, cc, yy.
• Text objects — inner/around word (iw / aw) and inner/around double-quotes (i" / a").
• Insert shortcuts — i insert, a append, o / O open line below/above, A append at line end, I insert at first non-blank.
• Replace — r replaces the character under the cursor.
• Visual operators — d / x delete, c change, y yank selection in Visual or Visual-Line mode.
• Ex commands — :w save, :q close tab, :wq / :x save & close, :q! force close. Command typed in an overlay at the bottom of the editor.
• Other — x delete char forward, p paste after, u undo.

Integrated debugger — DAP / lldb-dap (Mac)

Full Debug Adapter Protocol session against lldb-dap (brew install llvm). Open the Debug panel from the Activity Bar or press ⌘⇧D.

• Launch & attach modes — launch a binary directly or attach to a running process by PID.
• Gutter breakpoints — click any line number in the gutter to toggle a breakpoint; red dot appears instantly. Breakpoints are sent to the adapter at session start and updated live.
• Conditional breakpoints — add an LLDB expression to any breakpoint (e.g. x > 5); the adapter only stops when it evaluates to true.
• Execution controls — Continue, Step Over, Step In, Step Out.
• Execution-line arrow — a yellow arrow appears in the gutter at the current execution line while the program is stopped.
• Call stack & threads — browse all threads and stack frames; click a frame to switch to it and jump the editor to that source line.
• Variables & scopes — all DAP scopes (Locals, Arguments, Registers, …) shown; expand structs and arrays to any depth.
• Watch expressions — add expressions that are automatically re-evaluated every time the program stops.
• Debug console (evaluate) — evaluate any LLDB expression (po, arithmetic, member access) in the context of the selected stack frame.
• Save configuration — "Save to .vscode/launch.json" writes the current program path, working directory, and mode so LingCode pre-fills the panel on next open. Compatible with VS Code's launch.json format.

HTTP proxy inspector (Mac)

A localhost forward proxy for debugging plaintext HTTP traffic from your app — without installing a root CA or leaving the IDE. Point your app's HTTP client at http://localhost:<port> and every request and response lands in the inspector.

• Live capture — method, URL, headers, body, status, response headers, response body, and duration-in-milliseconds for each transaction, as it happens.
• Searchable history — filter by method, status, host, or body substring. Long bodies are truncated with a clear "truncated" indicator.
• Pretty-printed JSON and form data — bodies are syntax-highlighted when the content type is recognized; raw otherwise.
• No root CA install — intentionally HTTP-only. For HTTPS MitM, pair with Proxyman or Charles; the LingCode inspector covers plaintext dev servers, webhook receivers, and legacy APIs without cert gymnastics.
• Agent-accessible — the agent can read recent transactions when diagnosing flaky requests. Ask "why is the POST to /api/users returning 422?" and the agent reads the actual request body and response from the inspector.

Android development

LingCode ships a full Android toolchain in the same Mac app. No Android Studio required.

• Gradle build — module and variant detection; debug and release builds from the toolbar. Output parsed and streamed to the Build Log panel. run_build, run_tests, and run_clean all support Android targets (gradle test, gradle clean).
• AVD emulator control — list available AVDs, boot one, install and launch your APK, and pick it as a run destination alongside iOS simulators and physical devices.
• ADB & logcat — integrated adb for devices over USB or Wi-Fi debugging; live logcat streams to the Run Console with tag filtering.
• Kotlin debugger — JDWP-backed DAP session: breakpoints, stack frames, variables, watch expressions, and expression eval. Same Debug panel, same keybindings as LLDB.
• Manifest parsing — AndroidManifest.xml is parsed for permissions, activities, services, and launch intents.
• Gradle classpath for LSP — classpath resolved from Gradle so the Kotlin LSP sees your project's real dependencies.
• Signed AAB output — release builds produce a signed Android App Bundle ready for Play Console upload.
• Google Play deploy — service-account upload flow with preflight checks. Setup guide.
• Prereq checker — detects JDK, Android SDK, Gradle, and adb; tells you exactly what's missing.

Database tools (Mac)

A real database workspace built into the IDE — not just a SQL syntax-highlighter. Explore schema, run queries, edit rows, and let the agent see your database alongside your code.

PostgreSQL workspace

• Connection manager — save multiple connections (local, staging, prod) with URL or host/port/user/password; connections are stored in the Keychain.
• Schema tree — databases, schemas, tables, views, functions, indexes. Click a table to inspect columns, types, constraints, and foreign keys.
• Query runner — SQL editor with PostgreSQL-aware autocomplete (tables, columns, functions from the live catalog), syntax highlighting, and a result grid with row count and elapsed time.
• Row-level editing — click into any cell in a result grid and edit in place; the IDE writes a parameterized UPDATE behind the scenes.
• Explain plans — EXPLAIN ANALYZE output rendered as a readable plan tree, not raw text.

MySQL inspector

• Read-only schema and query view — same connection, schema tree, and query-runner UX as Postgres, scoped to what MySQL supports.

SQLite inspector & schema editor

• Open any .sqlite / .db / .db3 — via built-in libsqlite3, no external driver needed. Opens read-only by default so a rogue query can't corrupt your file.
• Table and column enumeration — PRAGMA table_info parsed into a clean schema panel with column types, PK flags, and null constraints.
• Ad-hoc SELECT with row cap — result grid caps rows by default so a SELECT * on a 10M-row table won't OOM.
• Schema editor — create or alter tables and indexes through a form; the IDE emits the correct DDL (CREATE TABLE, ALTER TABLE ADD COLUMN) with proper constraints.
• Mutation support — switch to write mode for INSERT/UPDATE/DELETE/DDL, with elapsed time and rows-affected feedback.

Agent access

• Database tools in the agent's registry — the agent can list schemas, describe tables, and run read-only queries against your configured connections. Ask "what's the schema of the users table?" or "how many orders shipped last week?" and the agent reads the live database, not a text description.
• Approval-gated writes — destructive statements (INSERT/UPDATE/DELETE/DDL) go through the same 5-layer safety gate as file edits; they require explicit approval per action.

Codebase index

Local, persistent index of every symbol in your project — used to give the AI better context and to power fast navigation. Runs entirely on your Mac.

• Parsed on open — Tree-sitter and swift-syntax extract classes, structs, enums, protocols, functions, variables, properties, typealiases, and extensions from every source file. Imports and file summaries are captured too.
• Persistent cache — the index serializes to ~/Library/Application Support/LingCode/codebase_index_cache/ and restores instantly on next launch. No re-parsing a 2,000-file project every time you open it.
• Fast lookup — symbol search, jump-to-symbol, and file-level symbol outlines all pull from the index, not from a live grep.
• Agent context — when the agent needs to know where a symbol is defined or how a type is used across the codebase, it reads from the index — fast, structured, and fully local. No embeddings, no cloud upload.

Rules & team standards

• Layered rules — core, project, user, and optional team rules with clear precedence.
• Cursor-compatible sources — .cursor/rules, .mdc with frontmatter, .cursorrules, WORKSPACE.md, .lingcoderules.
• Globs & scoped rules — file-scoped and alwaysApply behavior aligned with common Cursor setups.

Magic Deploy & Install (Mac)

• Magic Deploy — paste a token, URL, or SSH-style target; LingCode suggests a flow for platforms such as Vercel, Netlify, Fly.io, Railway, AWS-style SSH, and more (detection depends on input). For iOS or Mac App Store uploads, see the App Store Connect API key setup guide; for Android, the Google Play service account setup guide.
• Magic Install — detect stack and package manager (npm, pip, Cargo, CocoaPods, Flutter, and many others) and run installs from the UI.
• Git panel — stage, commit, and push; optional AI-generated commit messages from your diff (also reachable from Touch Bar on supported MacBook Pro models).

Extensions marketplace (Mac)

• LSPs & tools — browse and install language servers, formatters, and dev tooling from a curated marketplace.
• Plugins — extend behavior with supported plugin bundles where enabled.

Safety, validation & history (Mac)

• Pre-apply checks — lint and shadow-workspace style validation before risky applies (architecture described in the project README).
• Single write pipeline — centralized apply path with backups and atomic writes.
• Checkpoints — timeline of agent-driven edits with restore points.
• Privacy-first default — optional cloud; no mandatory telemetry; your keys stay on your machine when you use local or BYO-key providers.

Built for Mac — deep macOS integration

No cross-platform IDE comes close to this level of native integration. LingCode is wired into macOS at every layer:

Finder & system

• Finder Quick Action — right-click any file or folder in Finder → Quick Actions → "Open in LingCode".
• Finder Tags — agent-written files are automatically tagged so you can find them in Finder search or smart folders.
• File type associations — double-click Swift, JS, TS, Python, HTML, CSS, JSON, Markdown, Go, Rust files to open them directly in LingCode.
• iCloud Drive — open projects stored in iCloud Drive from the toolbar.
• Global hotkey (⌃⌥Space) — bring LingCode to focus from any app, no Accessibility permission required.
• Launch at Login — optional, enabled in Settings.

Apple ecosystem

• Handoff — start a project on one Mac, pick it up on another via the Dock or Lock Screen.
• Shortcuts & Siri — automate LingCode with the Shortcuts app: open a project, run an agent task, get or set font size.
• Focus Filter — mute agent notifications automatically when a Focus mode (Do Not Disturb, Work, etc.) is active.
• Home screen widget — live widget showing your current project name and agent status (idle / running).
• iCloud Settings Sync — theme, font size, tab size, keybinding profile, and other preferences sync across your Macs automatically.
• AppleScript — scriptable dictionary: open project, run agent task, get/set font size from any AppleScript or Automator workflow.
• Touch Bar — Save, Agent, Push, AI Panel, font-size controls on MacBook Pro Touch Bar.
• MetricKit — crash and hang reports delivered via Apple's MetricKit framework.

Native editor UX

• Customize Toolbar — right-click the toolbar → Customize Toolbar… to drag icons in, out, and rearrange, just like Finder or Mail. Run, Stop, the device picker, and Settings are locked in so you can’t accidentally remove them. Rarely-used tools (Postgres, Simulator, Recover, Zen Mode, Share, Split Editor, Call Hierarchy, …) ship out of the way in the Customize sheet — drag them into the toolbar if you want them one click away.
• Quick Look — press Space in the file tree to preview any file without opening it.
• Pinch-to-zoom — two-finger pinch on a trackpad to resize the editor font live.
• Writing Tools (macOS 15) — system Writing Tools work inside the editor.
• Spell check — continuous spell checking in the editor.
• Color picker — click a hex color in CSS/code to open the native macOS color wheel; edits update the value in place.
• Share Sheet — share the current file or the entire project folder via AirDrop, Mail, Messages, and more from the toolbar.
• Print — print code with monospaced formatting and proper margins (⌘P).
• Custom clipboard UTI — copied code carries language metadata so paste-aware apps can syntax-highlight it.
• State restoration — reopen LingCode exactly where you left off: same project, same open files, same AI conversations. Claude Code and Codex tabs persist their history across quit/relaunch.
• Dock badge — the Dock icon shows a badge while the agent is running.
• Native notifications — system notification when an agent task completes or fails, with summary and changed-file count.

iPad app

• AI chat — conversation-first interface with your providers and project context where available.
• Projects & files — browse and work with project content in the iPad workflow.
• Remote Control — saved hosts, tap to SSH, terminal session for command input; pairs with tmux on the Mac for Claude Code from iPad. Setup guide
• Appearance — full light and dark mode across every surface including terminals (custom ANSI palette for light mode), AI chat, diff views, and approval dialogs. Follows system appearance or set manually.