European AI Coding Assistants

AI coding assistants read your entire codebase, which makes where the model runs a genuine compliance question rather than a preference. These European and self-hostable options let you keep proprietary source inside EU jurisdiction — or inside your own network entirely — while still getting completion, refactoring and agentic editing.

How we rank these tools — 4-step process
  1. 1
    European ownership, verified

    The company is headquartered and incorporated in the EU, EEA or Switzerland, and processes customer data in Europe. A US parent company disqualifies a tool from this page regardless of where its servers are.

  2. 2
    Category fit and hands-on review

    What the tool actually does, who it suits, and where it falls short — checked against the vendor’s own documentation, changelog and pricing page rather than its marketing copy.

  3. 3
    Compliance and pricing check

    GDPR posture, hosting location and the prices quoted on this page are verified against the vendor’s public pricing before publication, and re-checked when we revisit the category.

  4. 4
    Position on this page

    Placement on this page can be paid, and that can affect the order tools appear in. It never buys a listing: a tool that fails the checks above is not here at any price, and payment does not change the shortcomings we write about. A vendor can ask us to correct a factual error — not to remove a criticism.

European Purpose may be paid for placements on this page and may earn a commission through links on it. Paid placement can affect the order in which tools appear; it never affects whether a tool is listed or what our review says. Editorial policy

7 European AI Coding Assistants

Mistral AI

European frontier models with Codestral for code generation

#1 of 7 in this category
France
Codestral EU inference Self-host option

Hugging Face

Open model hub with code models you can run yourself

#2 of 7 in this category
France
Open models Inference endpoints Self-host

JetBrains AI Assistant

AI built into the IDEs your team already uses

#3 of 7 in this category
Czech Republic
IDE-native Junie agent Local models

Lovable

Prompt-to-app builder that ships full-stack projects

#4 of 7 in this category
Sweden
Full-stack scaffolding GitHub sync Live preview

Refact.ai

Open-source AI agent for refactoring and completion

#5 of 7 in this category
Netherlands
Self-hosted Agentic edits Open source

Continue

Open-source IDE assistant you point at any model, including EU ones

#6 of 7 in this category
Open Source
Bring your own model VS Code + JetBrains Open source

Tabby

Self-hosted coding assistant — no code leaves your servers

#7 of 7 in this category
Open Source
Fully self-hosted No telemetry Team deployment

Key takeaways

  • Mistral AI ranks #1 among the European AI coding tools in this directory, because Codestral and the open-weight Mistral models are the European inference layer that several of the other tools here point at.
  • Refact.ai and Tabby are the only two options where source code provably never leaves your network — Refact.ai under BSD-3-Clause, Tabby under Apache 2.0 with no cloud component and no telemetry at all.
  • JetBrains AI Assistant is the pragmatic answer for teams already on IntelliJ, PyCharm, GoLand, Rider or WebStorm: no editor migration, and it uses the IDE's real code index rather than treating your project as text.
  • Lovable generates a complete React and Supabase project from a description with two-way GitHub sync, so the exit cost is a git clone rather than a rewrite.
  • Continue is the honest middle path: an Apache 2.0 plugin for VS Code and JetBrains that you point at any model — Mistral Codestral, an EU endpoint or a local Ollama server — so you decide where inference happens.

European AI coding assistants generate, complete and refactor source code using machine learning, from vendors in Europe or from open-source projects you can run yourself — where the deciding question is not which model is smartest but where your source code is processed.

European AI coding assistants compared

European AI coding assistants compared on position, country, entry price and best use
PositionToolEstablishedEntry priceBest for
#1 Mistral AI France Free tier / pay-per-use API Teams wanting European or self-hosted model inference behind their coding tools
#2 Hugging Face France Free tier / Pro from $9 per month / Enterprise Developers and researchers working directly with open models
#3 JetBrains AI Assistant Czech Republic Free tier / AI Pro from $10 per month / AI Ultimate from $30 per month Teams already standardised on IntelliJ, PyCharm, GoLand, Rider or WebStorm
#4 Lovable Sweden Free tier / Pro from $25 per month / Teams from $30 per user per month Founders and product teams building prototypes and internal tools fast
#5 Refact.ai Netherlands Free and open source self-hosted / Cloud from $10 per month Regulated teams that cannot send source code to a third-party service
#6 Continue Distributed Free and open source; you pay only your model provider Developers who want to keep VS Code but control where inference happens
#7 Tabby Distributed Free and open source; Enterprise tier for SSO and access control Organisations with a hard requirement that source code never leaves the network

Every European AI coding assistant reviewed

#1 Mistral AI

Paris, France Founded 2023 Free tier / pay-per-use API Free tier

Best for: Teams wanting European or self-hosted model inference behind their coding tools

Mistral belongs in this category as infrastructure rather than as an assistant you install. It publishes open-weight models including Codestral for code generation, which means the tools that let you choose a backend — Continue, Refact.ai, Tabby — can all be pointed at Mistral inference running in Europe or on your own hardware. That is the practical route to a European model behind a familiar editor.

The model lineup behind it is genuinely competitive rather than a regional alternative: Mistral Large 3 is a sparse mixture-of-experts model with 41 billion active of 675 billion total parameters and a 256,000-token context window, with Magistral covering reasoning and the compact Ministral 3 family at 3B and 7B for edge and resource-constrained deployment. Several of these ship as open weights, which no US frontier lab matches at that tier.

For a development team the arithmetic is straightforward. API usage starts from roughly €1 per million input tokens for Mistral Small, and self-hosting an open-weight model costs only compute, which beats per-token pricing once volume is real. Mistral AI operates from Paris, so API calls carrying code context stay in EU jurisdiction under French law rather than falling under the CLOUD Act.

What Mistral AI does well

  • Open-weight models including Codestral you can self-host
  • Powers Continue, Refact.ai and Tabby as a configurable backend
  • API in EU jurisdiction under French law
  • From about €1 per million input tokens for Small
  • Compact 3B and 7B models for local and edge use

Where Mistral AI falls short

  • Not an editor plugin — you need a tool in front of it
  • Frontier coding benchmarks still led by US labs
  • Fast release cadence requires attention to stay current
  • Self-hosting requires GPU capacity

Standout feature. The European inference layer the rest of this category can point at — and the reason "European AI coding" is a real option rather than a compromise.

#2 Hugging Face

Paris, France (and New York) Free tier / Pro from $9 per month / Enterprise Free tier

Best for: Developers and researchers working directly with open models

Hugging Face is where open machine learning is distributed, and for a development team its relevance is practical rather than philosophical: the Model Hub is how you find an open code model, the Transformers library is how you load it, and the Inference API is one way to serve it without building infrastructure.

Around that sit Datasets for training data, Spaces for interactive applications that let you try a model before committing, and deployment tooling that shortens the path from experiment to endpoint. For anyone evaluating whether a self-hosted assistant is viable, this is where that evaluation happens.

Hugging Face Inc. operates from Paris and New York, which is worth stating precisely: it is a French-rooted company with substantial US operations, not an EU-only vendor, so it does not satisfy a strict data-residency requirement on its own. What it does satisfy is the sovereignty argument in a different form — the models are downloadable, and a downloaded model has no jurisdiction at all. Free tier, Pro from $9 per month, Enterprise above that.

What Hugging Face does well

  • The distribution point for open models including code models
  • Transformers library and Inference API shorten the path to production
  • Spaces let you evaluate a model before committing
  • Downloadable models have no jurisdiction question at all
  • Free tier, Pro from $9/month

Where Hugging Face falls short

  • Paris and New York operations, not EU-only
  • A platform, not a coding assistant you install
  • Requires ML familiarity to get value from directly
  • Hosted inference is not the cheapest at scale

Standout feature. The place a self-hosted coding assistant gets its model — which makes it the starting point for anyone who wants inference on their own hardware.

#3 JetBrains AI Assistant

Prague, Czech Republic Founded 2000 Free tier / AI Pro from $10 per month / AI Ultimate from $30 per month Free tier, bundled in All Products Pack

Best for: Teams already standardised on IntelliJ, PyCharm, GoLand, Rider or WebStorm

JetBrains AI Assistant is the option with the lowest adoption cost for a large group of teams, because it requires no editor migration at all. It lives inside the IDEs those teams already use, offering context-aware completion, in-IDE chat, the Junie coding agent, commit message generation and multi-file edits.

Its structural advantage over editor-based rivals is the code index. JetBrains IDEs already maintain a resolved model of your project — symbols, types, references, structure — and the assistant works from that rather than from a window of text, which shows up in refactors and cross-file changes where textual context is not enough.

On data handling, JetBrains offers EU and US regions, enterprise terms excluding your code from training, and local model support through LM Studio or Ollama for work that must stay on the machine. JetBrains s.r.o. has operated from Prague since 2000, which is a longer track record than anything else in this category. A limited free tier, AI Pro from $10 per month, AI Ultimate from $30, and inclusion in the All Products Pack many teams already buy. The Junie agent is less mature than Cursor's agent mode, and the frontier models underneath are third-party rather than European.

What JetBrains AI Assistant does well

  • No editor migration for JetBrains teams
  • Uses the IDE's resolved code index, not just text
  • Local model option via LM Studio or Ollama
  • Bundled into the All Products Pack
  • Czech vendor under EU jurisdiction since 2000

Where JetBrains AI Assistant falls short

  • Only works inside JetBrains IDEs
  • Junie agent less mature than Cursor's agent mode
  • Frontier models are third-party, not European
  • AI Ultimate at $30/month is not cheap per seat

Standout feature. It reads the IDE's real code index rather than a text window — which is why its multi-file refactors land where text-based assistants guess.

#4 Lovable

Stockholm, Sweden Founded 2023 Free tier / Pro from $25 per month / Teams from $30 per user per month Free tier

Best for: Founders and product teams building prototypes and internal tools fast

Lovable turns a description into a working application, and what makes it more than a demo is what it produces: a conventional React and TypeScript project with Supabase handling data and authentication, not a proprietary format locked to the platform. Live preview shows the app as it builds, visual edit mode lets you adjust the interface directly instead of prompting for every change, and custom domains cover publishing.

The ownership story is the strongest argument. Two-way GitHub sync means the repository is yours throughout — clone it, hand it to your engineers, host it anywhere, stop paying Lovable. That is close to the opposite of typical no-code lock-in, where leaving means rebuilding.

Its natural place in a team is the front of the pipeline: prototypes, internal tools and the first clickable version of an idea, produced in an afternoon rather than a sprint. The output needs engineering review before it carries real users, and credit costs climb with heavy iteration. Lovable AB is based in Stockholm with EU project-data handling, though model inference runs through third-party providers, so a strict no-US-inference requirement rules it out. Free tier, Pro $25 per month, Teams $30 per user.

What Lovable does well

  • Produces conventional React and TypeScript you own
  • Two-way GitHub sync keeps exit cost near zero
  • Visual editing alongside prompting
  • Swedish company, EU project-data handling
  • Idea to clickable application in an afternoon

Where Lovable falls short

  • Output needs engineering review before production
  • Credit costs rise with heavy iteration
  • Model inference is not European
  • Not suited to editing a large existing codebase

Standout feature. Two-way GitHub sync: the generated project is a normal repository you can clone and keep, which is not how prompt-to-app usually ends.

#5 Refact.ai

Amsterdam, Netherlands Founded 2022 Free and open source self-hosted / Cloud from $10 per month Free, self-hosted

Best for: Regulated teams that cannot send source code to a third-party service

Refact.ai is a complete AI coding assistant that runs on your own hardware — completion, in-IDE chat and an autonomous agent for multi-step edits, with inference included in the self-hosted stack rather than called out to a cloud. For a bank, a defence supplier or a healthcare vendor, that is the difference between adopting AI assistance and not adopting it.

Fine-tuning on your own codebase is the feature that separates it from other self-hosted options. Completions learn your conventions, your internal libraries and your naming rather than reproducing the statistical average of public GitHub, which is where generic assistants get irritating in a large proprietary codebase. Plugins cover VS Code and JetBrains, so nobody changes editors.

It is open source under BSD-3-Clause and free when self-hosted, with a managed cloud from $10 per month for teams that want the tooling without the operations. Refact is based in Amsterdam under EU jurisdiction. The costs are real: you need GPU capacity, someone has to run it, locally runnable models trail frontier quality on complex reasoning, and the polish is below commercial assistants.

What Refact.ai does well

  • Runs entirely on your own hardware including inference
  • Open source under BSD-3-Clause, no per-seat cost self-hosted
  • Fine-tuning on your private codebase
  • Includes an agentic mode for multi-step edits
  • Amsterdam-based, EU jurisdiction

Where Refact.ai falls short

  • Requires GPU capacity and operational effort
  • Local models trail frontier quality
  • Less polished than commercial assistants
  • Fine-tuning needs enough code to be worth it

Standout feature. Fine-tuning on your own codebase, self-hosted: completions that match your conventions without a line of code leaving the building.

#6 Continue

Distributed Founded 2023 Free and open source; you pay only your model provider Free

Best for: Developers who want to keep VS Code but control where inference happens

Continue is a plugin rather than a product, and that is its entire value: it gives VS Code and JetBrains autocomplete, chat and agent mode while leaving the choice of model entirely to you. Point it at Mistral Codestral, at a European API endpoint, at a US provider, or at a local Ollama or vLLM server — the decision about where your code is processed becomes a configuration line rather than a vendor lock.

Context control is the second reason to choose it. Custom context providers make explicit what is sent with each request, so the assistant's inputs are inspectable rather than opaque — which is what allows a security team to actually review the deployment rather than accept a vendor statement about it.

It is Apache 2.0 and free, with no cost beyond whatever model provider you use. Two things belong in the governance note: it requires configuration and API key management rather than working out of the box, and the Continue project itself is US-incorporated even though nothing about your inference has to be. The agent mode also trails commercial rivals in maturity.

What Continue does well

  • Point it at any model, including EU and fully local ones
  • Apache 2.0 and free — you pay only your model provider
  • Explicit, inspectable context control
  • Works in both VS Code and JetBrains
  • No editor migration required

Where Continue falls short

  • Requires configuration and API key management
  • Agent mode behind commercial rivals
  • The project itself is US-incorporated
  • Quality depends entirely on the model you configure

Standout feature. Where your code goes is a line of configuration rather than a vendor decision — which is the only version of this choice you can actually audit.

#7 Tabby

Distributed Founded 2023 Free and open source; Enterprise tier for SSO and access control Free

Best for: Organisations with a hard requirement that source code never leaves the network

Tabby is built on a single premise: no code, no telemetry and no prompt ever leaves your infrastructure. There is no cloud component to disable and no optional data sharing to configure away — self-hosting is the only deployment model, which makes the compliance conversation short in a way that no vendor assurance can match. You remain the sole data controller.

It runs on consumer-grade GPUs, which keeps the hardware requirement realistic for a team rather than a data centre project, and it indexes your repositories so its answer engine responds from your actual code rather than general knowledge. Team management, an OpenAPI interface and completion across the usual languages round it out.

Apache 2.0 with no per-seat licensing, and an Enterprise tier adding SSO and access control for larger deployments. The limitations are the honest ones for this approach: locally runnable models are weaker on complex reasoning than frontier models, agentic capability is limited compared with commercial assistants, and the maintainer TabbyML is a US company even though the software runs entirely on your hardware — which for most buyers is immaterial, since nothing is sent to them.

What Tabby does well

  • No cloud component and no telemetry at all
  • Runs on consumer-grade GPUs
  • Answer engine grounded in your indexed repositories
  • Apache 2.0, no per-seat licensing
  • You remain sole data controller

Where Tabby falls short

  • Local models weaker on complex reasoning
  • Limited agentic capability
  • Maintainer is a US company
  • You operate and maintain the deployment

Standout feature. There is no cloud mode to accidentally leave enabled — self-hosting is the only way it runs.

Where does your source code actually go?

This is the question that separates these seven tools, and it has three distinct answers.

Nowhere: Tabby has no cloud component and no telemetry, running entirely on servers you control, so you remain the sole data controller. Refact.ai self-hosts the full stack on your own hardware including inference.

Wherever you configure: Continue routes inference to whatever provider you point it at — a European API, a US one, or a local Ollama or vLLM server on your own machine.

To a vendor: JetBrains AI Assistant sends context to EU or US regions depending on configuration, with enterprise no-training terms and a local-model option; Lovable processes project data in the EU but runs model inference through third-party providers. Both are reasonable; neither is "your code never leaves".

Which one fits your existing setup?

The migration cost is usually larger than the licence cost, so start there.

On JetBrains IDEs: JetBrains AI Assistant, because it needs no editor change and draws on the IDE's actual code index — resolved symbols and project structure rather than a text window. AI Pro is $10 per month, AI Ultimate $30, and it is bundled into the All Products Pack many teams already buy.

On VS Code and unwilling to move: Continue, Apache 2.0 and free, with completion, chat, agent mode and custom context providers. You pay only for whatever model you choose to call.

Building something from scratch rather than editing an existing codebase: Lovable, which produces a working React and Supabase application from a prompt, then hands you the code.

What does self-hosted AI coding actually cost you?

Hardware and operational effort, in exchange for eliminating a category of risk that some organisations cannot accept at all.

Tabby runs on consumer-grade GPUs and needs no cloud service, indexing your repositories so its answer engine responds from your actual code rather than general knowledge. Apache 2.0 with no per-seat licensing, and an Enterprise tier adding SSO and access control.

Refact.ai goes further with fine-tuning on your own codebase, so completions match your conventions rather than the average of GitHub, plus an agentic mode for multi-step edits. BSD-3-Clause, free self-hosted, $10 per month for the cloud version.

The honest trade-off is model quality. Locally runnable models trail frontier models on complex reasoning, and both projects are less polished than commercial assistants. For a bank, a defence contractor or a healthcare vendor whose code cannot leave the network, that trade is not close.

Is prompt-to-app a real category or a demo?

Real, with a specific and limited job: getting from an idea to something clickable in an afternoon.

Lovable generates a complete React and TypeScript project with Supabase for data and auth, live preview while it builds, visual edit mode alongside prompting, and custom domains. Because the output is conventional React rather than a proprietary format, and because GitHub sync is two-way, the code is genuinely yours — you can clone it and walk away, which is the opposite of most no-code lock-in.

What it does not do is produce production code unreviewed. The output needs engineering review before it carries real users, and credit costs climb with heavy iteration.

Lovable AB is Swedish with EU project-data handling, though model inference runs through third-party providers — so a strict "no US inference" requirement rules it out.

Is there a European model behind any of this?

Mistral, and it is worth understanding as infrastructure rather than as a competing assistant.

Mistral publishes open-weight models including Codestral for code, which means Continue, Refact.ai and Tabby can all be pointed at European or locally hosted Mistral inference. That is how a team gets a European model behind a familiar editor, and it is the practical reason Mistral sits at the top of this category.

Hugging Face plays the adjacent role: the Model Hub is where those open models are distributed, the Transformers library is how they are loaded, and the Inference API is one way to serve them. Pro is $9 per month; the hub itself is free.

Everywhere else in this category, the frontier models are third-party and mostly American, including inside JetBrains AI Assistant and Lovable. Saying so plainly is more useful than implying otherwise — the European part is the tooling and the jurisdiction, and with Mistral or a local model, the inference too.

How we selected and ranked these 7 tools

Every tool on this page is in the European Purpose directory, which means the operating company is established in Europe and we have verified that from the company register or the vendor's own legal notice rather than from a marketing page. Tools headquartered outside Europe are not eligible, however good they are.

  1. Feature verification (weight: 40%). We check each capability against the vendor's own documentation and product pages, and record what the tool does rather than what the category is assumed to include.
  2. Ease of adoption (weight: 30%). Integrations, published API access, trial availability and how much configuration stands between signing and a usable result.
  3. Value and transparency (weight: 30%). Published pricing counts in a vendor's favour; quote-only pricing is recorded as quote-only rather than estimated. We weigh what a buyer gets for the entry price, not the headline feature count.
  4. Editorial review. Three people touch every page: one writes it, a second edits it, and a third checks the compliance and pricing claims against the vendor's documentation. The three weights above decide the order; a position is a ranking against the other European tools in this category, not an absolute score.

Vendor-reported outcomes — ROI figures, margin uplift, time saved — are labelled as vendor claims wherever they appear on this page. We have not audited them, and neither has anyone else who quotes them. Read our full editorial process for how pages are re-verified.

Frequently asked questions

Mistral AI holds #1 among the European AI coding tools in this directory, because its open-weight models including Codestral are the European inference layer that Continue, Refact.ai and Tabby can all point at. For a working assistant, JetBrains AI Assistant from $10 per month is the pragmatic choice on JetBrains IDEs, and Refact.ai or Tabby are the answers when source code must never leave your network.

Tabby and Refact.ai, and the distinction from "GDPR compliant" is worth making. Tabby has no cloud component and no telemetry at all — it is self-hosted only, runs on consumer-grade GPUs, and leaves you as the sole data controller. Refact.ai self-hosts the full stack including inference on your own hardware under BSD-3-Clause, and adds fine-tuning on your own codebase. Both trade frontier model quality for that guarantee.

Several, depending on what matters. JetBrains AI Assistant from Prague works inside IntelliJ, PyCharm, GoLand, Rider and WebStorm from $10 per month with local model support and enterprise no-training terms. Continue is Apache 2.0 and free, working in VS Code and JetBrains while letting you route inference to a European or local model. Refact.ai from Amsterdam is fully self-hostable. Tabby is self-hosted only with no telemetry.

A limited free tier, AI Pro from $10 per month and AI Ultimate from $30 per month, and it is bundled into the All Products Pack that many JetBrains teams already buy — which for those teams makes the marginal cost zero. Its advantage over editor-based rivals is that it uses the IDE's real code index, working from resolved symbols and project structure rather than treating your project as text, and it needs no editor migration.

Yes. Tabby is designed for exactly that — self-hosted only, on consumer-grade GPUs, with no cloud component and no telemetry. Refact.ai runs its full stack on your own hardware including inference. Continue can be configured against a local Ollama or vLLM server. JetBrains AI Assistant supports local models through LM Studio or Ollama for part of its functionality. The constraint in every case is that locally runnable models trail frontier ones on complex reasoning.

Yes, with a clearer ownership story. Lovable generates a complete React and TypeScript project with Supabase for data and auth, live preview, visual edit mode alongside prompting and custom domains — and because the output is conventional React with two-way GitHub sync, you can clone the repository and walk away. Lovable AB is Swedish with EU project-data handling. Pro is $25 per month, Teams $30 per user. The output needs engineering review before production.

Continue, and that is its entire design. It is an Apache 2.0 plugin for VS Code and JetBrains offering autocomplete, chat, agent mode and custom context providers, pointed at whatever backend you configure — Mistral Codestral, a European API endpoint, or a fully local Ollama or vLLM server. You pay only your model provider. The trade-offs are configuration and key management, an agent mode behind commercial rivals, and a US-incorporated project.

Only where you make them so. Mistral publishes open-weight models including Codestral, which Continue, Refact.ai and Tabby can all be pointed at, and Hugging Face in Paris hosts and distributes open models through the Model Hub, Transformers library and Inference API. Elsewhere — inside JetBrains AI Assistant and Lovable — the frontier models are third-party and mostly American. The European part is the tooling and jurisdiction unless you choose the inference too.

Refact.ai can, through fine-tuning on your own codebase, so completions follow your patterns rather than the statistical average of public GitHub. Tabby takes a different route, indexing your repositories so its answer engine responds from your actual code, and JetBrains AI Assistant leans on the IDE's resolved code index for the same reason. Fine-tuning is the strongest of the three and also the one that needs GPU capacity and operational effort.