Aider

AI pair-programming terminal assistant

Aider is an open-source AI pair-programming application for the terminal. It works inside local Git repositories, uses a repository map to provide code context, applies edits across files, creates Git commits, and can run configured linting and test commands. It connects to a wide range of cloud and local language models rather than relying on one proprietary model.

Aider screenshot
Company Aider AI LLC
Free plan Yes
Ease of use Advanced

What you can do with Aider

Key features
✓
Repository-aware code editing

Builds a map of the Git repository so the model can work with relevant files, symbols, and project structure

✓
Multi-file code changes

Applies coordinated edits across files from natural-language coding requests

✓
Git change management

Creates commits with generated messages and supports diff, undo, and standard Git review workflows

✓
Flexible model connections

Lets users select cloud or local models from many providers, including OpenAI, Anthropic, Google, DeepSeek, OpenRouter, Ollama, and compatible APIs

✓
Automated linting and testing

Runs configured linters and test commands after changes and helps address detected failures

✓
Web and image context

Adds web pages, screenshots, and other images to the coding conversation for additional context

✓
Voice-to-code

Accepts spoken coding requests through the optional voice workflow

✓
IDE and scripting workflows

Runs beside editors, watches files for AI comments, and can be scripted through command-line or Python workflows

How Aider works

The user installs Aider, opens a terminal in a Git repository, selects a cloud or local language model, and adds the files relevant to the task. They describe the desired change in chat, review the proposed edits, and optionally let Aider commit changes or run configured tests and linters.

INPUTS
Text promptsCode filesGit repositoriesImagesURLsVoice
OUTPUTS
CodeText explanationsGit commitsTest and lint results

Who Aider is for

BEST FOR

Developers who prefer terminal workflows and want model-flexible AI assistance for modifying real Git repositories, refactoring code, debugging, adding tests, and making multi-file changes.

LESS SUITED FOR

Users who need a polished standalone graphical IDE, built-in hosted model access with predictable subscription billing, team administration, or a no-configuration coding experience.

Strengths & limitations

+ Strengths

  • Open-source and locally installable
  • works with a broad range of cloud and local models
  • strong Git integration
  • repository mapping helps provide project context
  • supports multi-file edits, testing, linting, web pages, images, and voice input
  • can fit into existing terminal and IDE workflows
  • avoids locking users to a single model provider.

– Limitations

  • Requires technical setup and command-line familiarity
  • users generally need separate model-provider credentials or local model infrastructure
  • model quality and cost vary by provider
  • execution and file-editing capabilities require careful review
  • it lacks the integrated visual workspace, team administration, and predictable hosted subscription experience offered by some commercial coding environments.

Pricing & access

FREE ACCESS Free plan available

The Aider software is open source and can be installed and used without an Aider subscription. Users may still incur separate charges from the language-model provider they connect to.

PAID ACCESS freemium

Aider itself does not advertise a recurring subscription price. Cloud model usage is normally billed separately by the selected provider. Local models and some free provider options may avoid or reduce API costs.

FREE TRIAL No free trial listed
USAGE LIMITS Plan limits apply

Usage limits depend primarily on the selected model provider, API account, model context window, local hardware, and provider quotas. Aider also depends on model capability and available context for reliable code editing.

Platforms & access

✓ Web app
– Mobile app
– Desktop app
– Browser extension
– API
– Embeddable

Terminal on macOS, Linux, and Windows; browser-based GUI mode is documented; can be used alongside IDEs and editors; supports local model servers and cloud model APIs.

Product format: standalone

Product specs

Standard features
✓ Web access
✓ File upload
– Memory
– Custom agents
– Scheduled automation
– Knowledge base
✓ Website ingestion
✓ Code execution
– Computer actions
✓ Integrations
– Webhooks
– MCP support
✓ Bring your own key
✓ Model selection
– Collaboration
– Shared workspace
– Admin controls
– SSO
– Role permissions
✓ Analytics
– Templates
– No-code
– Project workspace
– Brand tools
– Performance scoring

Aider supports repository mapping, Git integration, multi-file code edits, configurable model selection, cloud and local models, web and image context, voice coding, browser GUI mode, scripting, linting, testing, prompt caching, IDE/editor workflows, and multiple chat modes. No official mobile app, browser extension, hosted subscription plan, public Aider inference API, or MCP support was verified.

Categories & capabilities

Browse similar tools

Integrations & models

INTEGRATIONS Connected workflows

Integrates with numerous model providers and services, including OpenAI, Anthropic, Google Gemini, DeepSeek, OpenRouter, Groq, xAI, Azure, Cohere, Ollama, LM Studio, Vertex AI, Amazon Bedrock, GitHub Copilot, and OpenAI-compatible APIs. It also works with Git, IDEs, editors, Docker, GitHub Codespaces, and Replit.

MODELS Models used

User-selected third-party and local models, including models from OpenAI, Anthropic, Google Gemini, DeepSeek, OpenRouter, Groq, xAI, Cohere, Azure, Vertex AI, Amazon Bedrock, GitHub Copilot, Ollama, and LM Studio. The exact model varies by user configuration.

Privacy & data Data handling, AI training, retention and security
↓
Data handling

Aider is primarily a locally installed programming tool, but its privacy policy states that the provider may collect device, usage, error, command, and model information. Analytics can be disabled. Code and prompts sent to external model providers are subject to those providers' policies.

AI training

Aider's privacy documentation describes analytics and service-improvement data collection but does not establish that users' source code is used to train Aider's models. When external model providers are used, their individual data-training policies apply.

Data retention

Aider's consulted privacy policy does not specify a universal retention period for all collected information. Retention may vary by data type, service provider, and external model provider.

Security

Aider runs in the user's development environment and can modify local files, create Git commits, access configured repositories, fetch web pages, and run configured commands. Users should review proposed changes, protect API keys, and understand the permissions of their local environment and selected model provider.

About Aider

Aider brings AI pair programming into the terminal. Developers open an existing Git repository, describe a coding task in natural language, and review the resulting edits before committing, undoing, testing, or refining them. Because Aider is model-flexible and locally installed, it is aimed at developers who want control over their repository workflow rather than a fully managed visual coding environment.

What is Aider?

Aider is an open-source AI coding assistant designed for terminal-based software development. It runs in or alongside a local Git repository and uses a connected language model to help developers understand code, implement features, refactor files, fix bugs, and update tests or configuration.

Unlike a general-purpose chatbot, Aider is built around making changes to a real codebase. The user identifies relevant files, explains the desired change, reviews the proposed diff, and can ask Aider to revise or test the work. It can connect to models from providers such as OpenAI, Anthropic, and Google, as well as local model servers and OpenAI-compatible services.

How the coding workflow works

A typical session starts in a project directory. After Aider is installed and a model is configured, the developer adds the files that matter to the task and describes the change in chat. Aider uses the selected files and its repository map to provide the model with relevant code context.

The tool can apply coordinated edits across multiple files, show the resulting changes, and create Git commits with generated messages. Developers can inspect the diff, continue the conversation, undo changes, or use their normal Git workflow to review and manage the result. Aider can also run configured tests and linters, then help address failures.

Core capabilities for software development

Repository-aware editing

Aider's repository map helps the model understand project structure, symbols, and relationships beyond the contents of one pasted file. This is useful when a feature or refactor crosses several parts of a codebase, although the quality of the result still depends on the selected model and the context available to it.

Multi-file changes and Git integration

The main strength of Aider is its ability to turn a natural-language request into changes across an existing repository. Git integration provides a practical control layer: developers can review diffs, create commits, undo edits, and keep AI-generated work within an established version-control process.

Testing and linting

Aider can run configured test and lint commands after edits. This does not replace engineering review, but it makes the tool more useful for iterative debugging and for fixing straightforward errors exposed by the project's own checks.

Flexible model connections

Aider does not require one proprietary model. Users can select supported cloud services, compatible APIs, or local models through tools such as Ollama and LM Studio. The same coding workflow can therefore be used with different providers, pricing arrangements, or locally hosted infrastructure. Model selection also affects code quality, speed, context capacity, and cost.

Additional context and input methods

Web pages and images can be added as context for coding tasks, which can help when working from documentation, screenshots, or interface references. Optional voice-coding support allows users to dictate requests when the relevant dependencies are installed. These features supplement the core terminal coding workflow rather than turning Aider into a general multimedia assistant.

Who is Aider for?

Aider is best suited to software developers, open-source contributors, technical teams, and advanced users who are comfortable with terminals, Git, Python environments, API keys, and reviewing code. It can be useful for implementing features, navigating an unfamiliar repository, refactoring code, generating tests, explaining existing code, and applying fixes found by linters or test suites.

It is less suitable for someone who wants a polished standalone graphical IDE, built-in hosted model access with one predictable subscription, or a coding tool that requires little configuration. Developers who prefer visual agent environments may find products such as Cursor or Claude Code more aligned with their preferred workflow, though the choice depends on the desired interface, model access, and level of control.

Platforms and integrations

Aider is primarily a terminal application for macOS, Linux, and Windows. It can be used beside an editor or IDE, through scripting workflows, and in environments such as Docker, GitHub Codespaces, and Replit. Browser GUI mode is documented, but the product remains centered on local repository work rather than a hosted collaborative workspace.

Its integrations are mainly model and development-environment connections. Documented options include cloud providers, local model servers, OpenAI-compatible APIs, Git, editors, and several hosted development environments. Aider itself is not a general workflow automation platform, and no official public Aider inference API or MCP support was verified in the supplied research.

Pricing and access

The Aider software is open source and can be installed without an Aider subscription. There is no recurring Aider plan that determines access to the core application. Instead, users generally pay separately for the language model they connect to, according to that provider's pricing and quotas.

Local models and some free provider options can reduce or avoid API charges, but they may require suitable hardware and can provide different results from hosted models. Actual usage limits therefore depend on the selected provider, model context window, account quota, and local setup rather than on a single Aider-wide allowance.

Limitations and privacy considerations

Aider requires more technical setup than many hosted coding assistants. Users must configure a compatible model or API, understand repository and command permissions, and review changes carefully. Model quality, response speed, context handling, and cost vary substantially with the chosen provider. Running tests or other configured commands also means that users should understand what the local environment permits Aider to access or execute.

The tool can modify local files, create Git commits, retrieve web pages, and run configured commands. API keys should be protected, and code or prompts sent to an external model provider are subject to that provider's policies. Aider's privacy documentation describes collection of device, usage, error, command, and model information, with analytics controls available. The supplied research does not establish a universal retention period or a blanket policy that covers every external model provider, so organizations should assess both Aider's disclosures and the policies of the selected model service.

Is Aider a good fit?

Aider is a strong fit for developers who already work in Git and want model choice, terminal control, and a direct path from conversational instructions to repository edits. Its combination of repository mapping, multi-file changes, Git operations, and test or lint execution makes it practical for hands-on development rather than occasional code snippets.

It is a weaker fit for teams seeking built-in administration, shared workspaces, enterprise identity controls, or a fully managed coding environment. The need to supply or operate a model is also important: Aider provides the coding workflow, but the capability, billing, privacy terms, and reliability of the underlying model remain central to the overall experience.

Aider is an open-source terminal coding assistant that works inside Git repositories. It connects to cloud or local models, applies multi-file edits, supports Git review and commits, and can run tests and linters. It is free to install, but external model usage may cost extra.

Answers to Frequently Asked Questions

What is Aider used for?
Aider is an open-source, terminal-based AI coding assistant used to understand code, implement features, refactor files, fix bugs, update tests, and modify configuration in a local Git repository.
Which AI models and providers can Aider use?
Aider can connect to models from providers such as OpenAI, Anthropic, and Google, as well as local model servers and OpenAI-compatible APIs. It also supports local setups involving tools such as Ollama and LM Studio.
Who is Aider best suited for?
Aider is best suited to developers, open-source contributors, technical teams, and advanced users who are comfortable with terminals, Git, Python environments, API keys, and reviewing AI-generated code. It is less suitable for users seeking a fully managed graphical IDE with built-in model access.
Does Aider have a subscription or usage fee?
Aider is open source and can be installed without an Aider subscription. Users generally pay separately for the connected language model, although local models and some free provider options may reduce or avoid API charges.
How does Aider work with Git repositories?
Developers run Aider in a project directory, add relevant files, describe the desired change, review the generated diff, and optionally ask Aider to revise or test the work. Aider can also create Git commits, undo edits, and fit into a normal Git review workflow.