What Are Local AI Coding Models? Best Tools & Models

26 min read

What Are Local AI Coding Models?

Local AI coding models are artificial intelligence models that run on your own computer or private infrastructure to help you write, understand, debug, and improve code without sending every request to a cloud-based AI service. These models are becoming popular among developers who want better privacy, offline access, customizable workflows, and greater control over their software development environment. From generating Python scripts to building complete applications with React and Next.js, local AI coding models can support many stages of modern software development.

Unlike traditional cloud-based coding assistants, local models can process prompts and source code directly on your machine when the model, runtime, and required dependencies are installed. Tools such as Ollama, LM Studio, and llama.cpp make it easier to download and run coding models, while applications such as Continue.dev, Aider, OpenHands, and TabbyML help integrate AI into everyday development workflows.

However, not every model offers the same level of intelligence, speed, hardware efficiency, or programming ability. Choosing the right solution requires understanding model size, RAM requirements, GPU performance, quantization, context length, licensing, and compatibility with your preferred programming languages.

This guide explains how local AI coding models work, which models and tools developers should consider, how to run them on Windows, Linux, and macOS, and how to select a suitable coding assistant for your hardware and development goals.

What Are Local AI Coding Models?

Local AI coding models are large language models (LLMs) trained or fine-tuned to understand programming languages, generate source code, explain algorithms, identify errors, and assist with software engineering tasks. Instead of relying exclusively on a remote inference service, developers can download compatible model weights and run inference on their own hardware.

These systems are also known as local large language models for software development, local AI programming assistants, self-hosted coding AI, private AI coding tools, or on-device LLMs for coding.

For example, a developer can ask a local model to create a Python function, explain a JavaScript error, refactor a TypeScript component, or write a SQL query. The model generates a response based on its training, the supplied instructions, and any relevant source code included in the prompt.

You can explore our complete guide to local AI coding models to understand the available models, tools, and setup options.

How Do Local Coding Models Work?

A local coding assistant generally includes three components:

1. The model: A trained neural network that predicts and generates text or code.
2. The inference runtime: Software that loads the model and performs calculations using your CPU, GPU, or supported accelerator.
3. The coding interface: An application, terminal tool, or IDE extension that sends prompts to the model and displays its responses.

Some workflows add repository indexing, file editing, terminal execution, testing, and tool integrations. These capabilities allow an AI assistant to work with more than an isolated code snippet.

For example, a developer using VS Code can connect an editor extension to a locally running model through a supported API. The assistant can then help write functions, explain selected code, or propose changes without necessarily sending source files to an external provider.

Local AI Models vs. Cloud-Based Coding Assistants

Cloud-based assistants usually run models on remote servers. This arrangement can provide access to powerful models without requiring users to purchase high-end hardware. Local models, by contrast, offer more control over execution, data handling, and operating costs.

Neither approach is universally better. A small local model may be excellent for autocomplete and simple code explanations, while a powerful cloud model may handle complex debugging or large repository changes more effectively.

The right choice depends on the developer’s hardware, programming requirements, privacy needs, and budget.

Benefits of Running AI Coding Models Locally

Learning how to run AI coding models locally can help developers create a more flexible and private development environment.

1. Privacy and Data Security

Privacy is one of the main reasons developers choose local AI tools. Proprietary source code, internal documentation, configuration files, and other sensitive information can remain on infrastructure controlled by the developer.

Privacy-focused coding is particularly useful for businesses working with confidential applications, private repositories, or regulated information.

However, running a model locally does not automatically guarantee complete security. Extensions may communicate with external services, and downloaded models or supporting applications may introduce risks. Developers should inspect network activity, configure integrations carefully, and review the software’s data-handling policies.

2. Offline AI Code Generation

Once the required model files, runtime, and dependencies are installed, offline AI code generation can work without an internet connection.

This is valuable for developers who travel frequently, work in environments with unreliable connectivity, or need to maintain access to programming assistance while offline.

Air-gapped development environments can also benefit from locally deployed models. Nevertheless, downloading updates, installing dependencies, or accessing external documentation may still require a separate connected system.

3. Greater Control and Customization

Self-hosted coding AI allows developers to select their preferred models, quantization levels, system prompts, context settings, and integrations.

Teams can build customized workflows for code review, documentation generation, internal frameworks, or organization-specific development standards.

4. Predictable Infrastructure Costs

Local inference can reduce dependence on usage-based cloud APIs. After acquiring the necessary hardware, developers can run models without paying a separate provider for every generated token.

However, electricity consumption, hardware depreciation, storage, maintenance, and setup time still contribute to the total cost.

Best Local Coding LLMs to Consider

The best local coding LLMs depend on the task, available hardware, and model licensing. Model families evolve quickly, so developers should verify current releases, supported runtimes, and license terms before choosing a particular version.

The following models are useful starting points for comparing the best open-source coding models and other locally deployable AI systems.

Qwen Coder and Qwen3-Coder

Qwen Coder models are designed for programming tasks, including code generation, completion, and problem-solving. Qwen3-Coder is a newer generation in the Qwen coding family and includes models intended for different levels of complexity and resource availability.

Developers can investigate these models for repository-level tasks, code generation, and agentic programming workflows. Larger variants may require substantial memory, while smaller variants can be more practical for personal computers.

Always verify the exact model variant, supported quantizations, license, and runtime compatibility before installation.

DeepSeek-Coder and DeepSeek-Coder-V2

DeepSeek-Coder and DeepSeek-Coder-V2 are coding-focused model families associated with source-code generation, completion, and programming assistance.

DeepSeek-Coder-V2 introduced a mixture-of-experts architecture in relevant releases, allowing the model to activate selected experts for processing. Although this architecture can reduce active computation relative to the total parameter count, memory requirements still depend on the model’s complete architecture, weights, context configuration, and runtime.

DeepSeek-R1

DeepSeek-R1 is a reasoning-oriented model family rather than simply a code-completion model. It can be useful for algorithmic reasoning, debugging explanations, and multistep problem-solving.

However, reasoning ability does not guarantee superior performance on every programming task. Developers should compare actual coding results, execution correctness, latency, and memory usage.

Code Llama

Code Llama is an established family of coding models built on Meta’s Llama ecosystem. It supports programming-related tasks such as code generation and completion.

Although it remains useful for understanding local AI workflows and legacy setups, developers should compare it against newer models before choosing it for a new production environment.

StarCoder2

StarCoder2 is an open code-model family associated with the BigCode research community. It supports source-code generation and completion across programming languages.

Its fill-in-the-middle capabilities are especially relevant to editor-based workflows in which a model must generate code between an existing prefix and suffix.

Codestral

Codestral is a coding-oriented model family from Mistral AI. Relevant releases have supported tasks such as code completion and generation.

Before deploying Codestral locally, verify the license and terms of use for the exact version, particularly if you intend to use it commercially. A model being available for download does not necessarily mean that it is unrestricted open-source software.

Devstral

Devstral is associated with software-engineering and coding-agent workflows. Depending on the release, its capabilities may include working with repositories and performing multistep coding tasks.

Check the exact model size, license, inference requirements, and agent compatibility before integrating it into a development environment.

IBM Granite Code

IBM Granite Code models are designed for code-related tasks and enterprise-oriented development use cases. They can be evaluated for code generation, explanation, and related programming assistance.

Review the license and deployment documentation for the specific release to understand the permitted uses and technical requirements.

Phi Coding Models

Phi coding models are relevant when developers want to explore smaller models that may fit constrained hardware. Their practical performance depends on the specific release, parameter count, quantization, and workload.

Smaller models can be suitable for autocomplete, straightforward functions, and explanations, although they may struggle with complicated repository-wide changes.

Gemma Coding Models

Gemma coding-capable models can provide another option for local programming assistance. Developers should distinguish between general-purpose Gemma releases and variants specifically tuned for coding.

Check the model card and license terms rather than assuming every model in the family has identical capabilities or permissions.

GLM Coding Models and Llama Coding Models

GLM coding models and Llama coding models are additional families worth evaluating when building a local AI development environment.

Their suitability depends on coding benchmarks, model architecture, quantization availability, supported context length, runtime compatibility, and the exact license attached to the release.

Tools for Running Local AI Coding Models

Choosing a model is only one part of the process. You also need a runtime and, in many cases, a coding interface.

Ollama Coding Models

Ollama simplifies downloading, managing, and running supported local language models. It offers a command-line interface and local API that other applications can use.

A basic workflow is:

1. Install Ollama from its official website.
2. Select a supported coding model from its model library.
3. Download the model.
4. Start an interactive session.
5. Connect compatible coding tools if needed.

For example, the following command demonstrates how to run a model after selecting a suitable model identifier:

ollama run qwen2.5-coder:7b

This is an illustrative example; availability and exact model identifiers may change. Confirm the identifier in the current Ollama model library.

Ollama coding models are particularly useful for developers who want a relatively straightforward installation process without manually configuring every inference parameter.

LM Studio Coding Models

LM Studio provides a graphical interface for discovering, downloading, and running compatible models. It is useful for developers who prefer selecting models and adjusting settings through a desktop application.

LM Studio coding models can be tested through chat interfaces and, where supported, local API endpoints. Developers can compare different model variants, adjust context settings, and experiment with quantization.

llama.cpp

llama.cpp is a lightweight inference engine focused on efficient local execution of supported models. It is widely associated with GGUF model files and supports different hardware configurations.

It is especially useful for developers who want more control over inference parameters, memory use, CPU execution, and compatible GPU acceleration.

Hugging Face Coding Models

Hugging Face hosts model repositories, documentation, model cards, datasets, and development tools. Developers can explore Hugging Face coding models to compare architectures, parameter counts, training information, supported tasks, and licensing.

Not every model hosted on Hugging Face is optimized for local inference. Some require specialized libraries, substantial hardware, or additional configuration.

Continue.dev

Continue.dev integrates AI assistance into supported development environments. Depending on the current version and configuration, developers can connect compatible local models for chat, editing, and autocomplete workflows.

This makes it useful for developers who want VS Code local AI without switching to a separate application for every coding task.

Aider

Aider is a terminal-oriented AI coding assistant that can work with Git repositories. With compatible model providers and configuration, it can help edit files, implement changes, and integrate those changes into version-controlled workflows.

Developers should verify that their chosen local model supports the interaction patterns required by their Aider configuration.

OpenHands

OpenHands focuses on AI-driven software development tasks. Its workflows may involve repository inspection, terminal operations, and multistep problem-solving.

Local deployment can be more demanding than running a simple chat model because the complete environment may include containers, tools, orchestration, and additional services.

TabbyML

TabbyML is a self-hosted AI coding assistant project associated with code completion and developer productivity. It is relevant to teams that want more control over their coding-assistance infrastructure.

Evaluate its current supported models, hardware requirements, authentication options, and deployment configuration before using it in a production environment.

How Local Coding Models Support Software Development

Local models can assist with several stages of the software development lifecycle, from writing individual lines to helping investigate failures across a repository.

Local AI Code Completion and AI-Powered Code Autocomplete

Local AI code completion predicts useful code as developers type. AI-powered code autocomplete can suggest variable names, function bodies, imports, and repeated programming patterns.

For this task, a compact model with low inference latency may be more practical than a very large reasoning model.

Code Generation From Natural Language

Code generation from natural language allows developers to describe a requirement in plain English and receive a code implementation.

For example, a prompt might request a TypeScript function that validates an email address or a Python script that processes CSV files.

Generated code should still be reviewed, tested, and checked for edge cases before it is used in production.

AI Debugging and Code Explanation

AI debugging can help interpret stack traces, identify likely causes of exceptions, and suggest ways to reproduce problems.

Code explanation is useful when developers need to understand unfamiliar functions, legacy systems, complex algorithms, or third-party libraries.

The model’s answer is a hypothesis rather than guaranteed proof. Verify proposed explanations against actual program behavior.

Code Refactoring

Code refactoring involves improving code structure without intentionally changing its external behavior. Local models can suggest smaller functions, clearer variable names, reduced duplication, and better organization.

Automated tests are particularly important when applying model-generated refactoring changes.

Repository-Aware Coding

Repository-aware coding uses relevant project files, documentation, and source context to produce more accurate answers than a model working with an isolated snippet.

Depending on the tool, this may involve codebase indexing, file retrieval, context selection, and references to existing functions.

AI Agentic Coding and Autonomous Software Development

AI agentic coding allows a model to participate in a sequence of development actions, such as inspecting files, proposing edits, running tests, and correcting failures.

Local coding agents can support parts of autonomous software development, but they need suitable tools, permissions, and execution environments. They should not be given unrestricted access to sensitive files or production systems.

How to Choose Hardware for Local Coding Models

Hardware determines which models can run comfortably and how quickly they respond.

GPU Requirements for Local LLMs

A GPU can accelerate inference by performing parallel computations. NVIDIA CUDA is widely used for compatible NVIDIA GPUs, while AMD ROCm supports selected AMD hardware and software configurations.

Support depends on the operating system, GPU architecture, runtime, drivers, and model implementation. A compatible GPU is not always required because CPU inference is also possible.

VRAM Requirements

VRAM is the memory available on a graphics card. Larger models and longer context windows generally require more memory.

The following table provides broad planning estimates, not guaranteed minimum requirements. Actual usage depends on architecture, quantization, runtime overhead, and context length.

These ranges overlap considerably. A model can exceed the available memory even when its parameter count appears suitable.

RAM Requirements

System RAM matters when models run on the CPU or when the runtime offloads some layers from GPU memory.

The best local coding model for 16GB, 32GB, or 64GB RAM depends on whether the system also has a dedicated GPU and how much memory other applications consume.

Apple Silicon and Mac M-Series Chips

Apple Silicon and Mac M-series chips can run compatible local models using supported runtimes and unified memory. Unified memory allows the CPU and GPU to access a shared memory pool, although available capacity and performance vary by device.

Before choosing a Mac, consider memory capacity, model size, thermal performance, context length, and the supported inference backend.

CPU Inference

CPU inference allows developers to run local models without a dedicated GPU. It is useful for experimentation, basic code explanation, and situations where GPU hardware is unavailable.

However, generation speed may be considerably slower, particularly for larger models. Compare tokens per second and actual task completion time rather than assuming that a model’s parameter count alone predicts responsiveness.

Understanding Quantization and GGUF Models

Quantization reduces the precision used to represent model weights. It can lower memory requirements and improve practical inference performance, sometimes with a trade-off in output quality.

4-Bit Quantization and 8-Bit Quantization

4-bit quantization compresses weights more aggressively, making larger models easier to fit into limited memory. 8-bit quantization usually uses more memory but may preserve more numerical precision.

Neither format guarantees a particular level of coding quality. Results vary by quantization method and model.

GGUF Models

GGUF is a model file format commonly used by llama.cpp and compatible tools. It can package model weights and related metadata for supported inference workflows.

Common variants include:

• GGUF Q4_K_M: A popular 4-bit quantization option that balances model size and quality.
• GGUF Q5_K_M: A higher-bit quantization option that typically uses more memory than Q4_K_M.
• GGUF Q8_0: An 8-bit quantization option that generally requires substantially more storage than comparable 4-bit versions.

Always check the actual file size and runtime memory requirements before downloading a model.

Context Window, Inference Latency, and Model Performance

A model’s parameter count is only one factor in its usefulness.

Model Context Window and Context Length

The model context window determines how much input and generated content the model can process within a request. A longer context can help when analyzing multiple source files or lengthy documentation.

However, large contexts can increase memory consumption and inference time. Effective context handling also depends on how much relevant information the application supplies.

Tokens Per Second and Inference Latency

Tokens per second measures the rate at which a model generates tokens. Inference latency measures the delay before or during a response.

Autocomplete systems benefit from low latency, while complex debugging tasks may justify slower responses if the result is more accurate.

When comparing models, measure performance on your own hardware with realistic prompts and context sizes.

Code Benchmark Performance

Code benchmark performance provides a useful starting point, but individual scores do not tell the whole story.

• HumanEval: Evaluates generated programs using programming problems and execution-based tests.
• MBPP: Contains introductory Python programming problems designed to assess code generation.
• SWE-bench: Evaluates models on software-engineering tasks involving real GitHub issues and code repositories.

Results depend on the benchmark version, evaluation methodology, model configuration, and whether tools or repeated attempts are permitted.

Advanced Features to Evaluate

Fill-in-the-Middle (FIM)

Fill-in-the-middle (FIM) enables a model to generate code between an existing prefix and suffix. It is especially useful for inline code completion because developers often need to modify the middle of an existing function without replacing the entire file.

Function Calling and Tool Use

Function calling allows a model to request structured actions from supported tools. Tool use can enable workflows such as searching files, running tests, or retrieving documentation.

These features depend on the model, runtime, and application. A model that generates plausible tool-call syntax does not necessarily support reliable tool execution.

MCP Support

The Model Context Protocol (MCP) provides a standardized way for compatible AI applications to connect with external tools and data sources.

MCP support can extend local coding workflows, but compatibility varies. Connecting an external MCP server may also introduce network access or data-sharing risks, even when the underlying model runs locally.

Local RAG for Codebases

Local RAG for codebases combines retrieval-augmented generation with project-specific information. A retrieval system identifies relevant files, functions, documentation, or code examples and adds them to the model’s context.

This can improve repository-aware coding without requiring the model to process the entire repository at once.

Codebase Indexing and IDE Integration

Codebase indexing helps an assistant find relevant code across a project. IDE integration connects model capabilities with editor features such as autocomplete, chat, inline editing, and diagnostics.

For large repositories, retrieval quality and indexing accuracy can be as important as model size.

How to Run AI Coding Models Locally With Ollama

Ollama offers a straightforward way to get started with local inference.

Step 1: Install Ollama

Download the installer appropriate for Windows, Linux, or macOS from the official Ollama website. Follow the installation instructions for your operating system.

Step 2: Choose a Coding Model

Review the available model library and choose a model that matches your hardware. For example, a smaller Qwen Coder variant can be a practical starting point for experimentation.

Step 3: Download and Run the Model

Use the command shown on the model’s official library page. A typical workflow looks like this:

ollama pull qwen2.5-coder:7b
ollama run qwen2.5-coder:7b

Model availability and identifiers may change, so confirm that the selected tag remains supported.

Step 4: Test the Model

Try realistic prompts involving code generation, debugging, and explanation. For example:

Write a Python function that reads a CSV file,
validates required columns, and reports invalid rows.
Include error handling and a short explanation.

Run the generated code in a controlled environment and test both normal and invalid inputs.

Step 5: Connect Your Development Tools

Configure a compatible application, such as Continue.dev, to connect to the local inference service. Follow the current documentation for the model provider, endpoint, and supported integration features.

This workflow demonstrates how to connect local LLMs to VS Code without relying entirely on a cloud-hosted coding assistant.

Installing Local AI Models on Windows, Linux, and macOS

The installation process differs slightly across operating systems, although the overall workflow remains similar.

Windows

Windows users can begin with Ollama or LM Studio. Verify GPU drivers, available memory, and compatibility with the selected inference backend. VS Code users can then configure a supported extension to access their local model.

Linux

Linux provides flexibility for CPU and GPU inference. Developers should verify the distribution’s dependencies, GPU drivers, NVIDIA CUDA or AMD ROCm compatibility, and runtime-specific installation requirements.

macOS

macOS users can explore Ollama, LM Studio, and compatible llama.cpp builds. Apple Silicon users should pay particular attention to unified memory capacity and supported acceleration features.

In every operating system, download model files and installers from trustworthy sources, keep software updated, and check the model’s license before commercial deployment.

How to Build a Private Local AI Coding Assistant

A private local AI coding assistant can combine a model runtime, an editor integration, repository retrieval, and carefully controlled tools.

A basic architecture includes:

1. A local inference engine such as Ollama or llama.cpp.
2. A coding model selected for the target hardware.
3. An IDE integration for chat, autocomplete, and editing.
4. A retrieval system for repository files and documentation.
5. Optional tools for testing, linting, and version control.
6. Security controls governing file access, network requests, and command execution.

For example, a development team could connect Continue.dev to a local model, configure retrieval for internal documentation, and use existing automated tests to validate proposed code changes.

More advanced setups can incorporate Aider or OpenHands for repository-level tasks. Teams should use isolated environments, review diffs, and require approval before executing potentially destructive operations.

Security Considerations for Private Coding Tools

Privacy-focused coding requires more than local model execution. Developers should inspect extension permissions, secure API endpoints, avoid exposing local services publicly, and protect logs that may contain proprietary source code.

Air-gapped development can provide additional isolation when implemented correctly. However, model files and dependencies must still be obtained, verified, and transferred securely.

Commercial licensing should also be reviewed carefully. Open-source licenses and model-specific licenses may impose different conditions on redistribution, modification, or commercial use.

Local AI Versus Cloud AI Coding Assistants

Local models versus cloud AI coding assistants is an important comparison for developers deciding how to organize their workflow.

Local Models vs. GitHub Copilot

GitHub Copilot offers an integrated coding-assistance experience across supported development environments. Local models can offer more control over execution and data handling, but the experience depends on the selected model and integration.

Choose based on code quality, privacy requirements, latency, and the amount of configuration you are willing to manage.

Local Models vs. Cursor

Cursor provides an AI-focused coding environment with features designed around editing, repository understanding, and developer workflows. Local models may offer an alternative for users prioritizing local inference, but feature parity depends on the integration and model.

Local Models vs. Claude Code

Claude Code is an AI coding agent designed to work with development projects and tools. Local alternatives can support similar categories of tasks, but the reliability of multistep reasoning, repository editing, and tool use varies significantly.

Local Models vs. ChatGPT

ChatGPT provides access to hosted AI capabilities through its supported interfaces and tools. Local models give developers more control over the execution environment but may require additional setup and may not match the strongest hosted models on difficult tasks.

A hybrid approach can be effective: use a local model for routine code completion and private experimentation, then use an approved cloud service when a task requires capabilities that the local model cannot provide.

Which Local Coding Model Is Best for Your Needs?

The best local coding model depends on your hardware, programming language, reasoning ability, code quality requirements, speed, privacy, licensing, and cost.

Best Local Coding Model for 8GB VRAM

With 8GB VRAM, start by evaluating smaller models or quantized variants. Lightweight coding models are often more practical for autocomplete, short functions, and basic explanations.

Remember that context length and runtime overhead consume additional memory, so a model that loads successfully may still be slow or unstable under a demanding workload.

Best Local Coding Model for 12GB VRAM

A 12GB GPU can provide more flexibility for medium-sized quantized models. Compare small and medium Qwen Coder, DeepSeek-Coder, or other compatible variants on your own tasks.

Best Local Coding Model for 16GB VRAM

A 16GB GPU can accommodate some larger quantized models, depending on the architecture and context settings. Test repository-aware coding, debugging, and completion separately rather than relying on one general benchmark.

Best Local Coding Model for 24GB VRAM

A 24GB GPU offers greater flexibility for larger models and more demanding contexts. However, the most capable available model may still exceed memory limits or run too slowly for practical use.

Which Local Coding Model Is Fastest?

There is no universally fastest local coding model. Speed depends on model size, quantization, hardware, runtime optimization, context length, and generation settings.

Measure tokens per second and end-to-end latency using the same prompts and environment.

Which Local Model Produces the Best Code?

The strongest coding model is the one that reliably solves your target tasks. Compare compilation success, unit-test results, correctness, maintainability, security, and the number of corrections required.

For repository-level work, evaluate actual issue resolution rather than judging performance only on short code-generation benchmarks.

Which Coding Model Works Without Internet?

A compatible model can work without internet after the required weights, runtime, dependencies, and supporting tools have been installed. Ollama, LM Studio, and llama.cpp can support offline workflows under suitable configurations.

An IDE extension or external integration may still require connectivity, so test the entire setup before relying on it in an offline environment.

Which Local AI Model Is Best for Beginners?

Beginners can start with Ollama or LM Studio and a relatively small coding model. A straightforward interface, clear documentation, modest memory requirements, and reliable language support are often more valuable than selecting the largest model available.

Start with simple code generation, gradually introduce debugging and repository-level tasks, and learn to validate every suggested change.

Frequently Asked Questions

Conclusion

Local AI coding models give developers a practical way to integrate AI into software development while maintaining greater control over their hardware, data, and development environment. Options such as Qwen Coder, DeepSeek-Coder, StarCoder2, and other coding-capable model families can support code generation, debugging, refactoring, explanation, and autocomplete when paired with compatible runtimes.

Tools such as Ollama, LM Studio, llama.cpp, Continue.dev, Aider, OpenHands, and TabbyML make it possible to create workflows ranging from a simple offline programming assistant to a more advanced repository-aware coding agent.

The best choice is not necessarily the largest model or the newest release. Select a model that fits your available RAM and VRAM, performs well on your programming tasks, supports your preferred tools, and meets your privacy and licensing requirements. Test it against real projects, verify generated code with automated tests, and expand your setup as your needs grow.

For more guidance, visit our detailed resource on local AI coding models and continue exploring practical AI-assisted software development techniques on ccodelearner.