I need a cloud IDE that is self-hosted and does not send code to third parties.

Yes. If your requirement is “the IDE runs on infrastructure I control, and source code is not sent to the IDE vendor”, there are several good options.

Best options

• Coder + code-server — my top pick for teams. Coder runs the control plane and development workspaces on your infrastructure, supports VMs/Kubernetes/Docker, and can even be deployed in air-gapped environments.
• code-server — best for a simple setup. It gives you VS Code in the browser and runs on your own Linux machine/server. Its FAQ specifically notes that its self-contained web views don't call Microsoft's servers.
• OpenVSCode Server — another lightweight, open-source way to run VS Code in a browser on your own machine, including via Docker.

What I'd choose

Important caveat: self-hosting the IDE doesn't automatically mean nothing leaves your network. Extensions, package managers, Git remotes, telemetry, AI coding assistants, etc. can independently make outbound connections. For a genuinely no-third-party-code-egress environment, I'd run the IDE in a restricted network and use an internal extension registry/package mirrors, while explicitly disabling telemetry and external AI services.

If you tell me whether this is for one developer, a small team, or an enterprise, I can recommend a concrete architecture (e.g. Docker/Kubernetes + VPN + SSO + private Git + no-egress firewall) and keep the code entirely under your control.

To run a cloud-based, browser-accessible IDE entirely on your own infrastructure without leaking code or telemetry to third parties, you have a few robust, open-source options.

The top options for self-hosted cloud IDEs include:

- **What it is:** This is VS Code running on a remote server [7], accessible directly through your web browser.
- **Privacy & Control:** Completely self-hosted. It runs locally in your environment (Docker or Linux machine). It does not send your code anywhere. By default, it uses the Open VSX Registry for extensions rather than Microsoft's proprietary marketplace, reducing third-party telemetry.
- **Resource needs:** Lightweight; requires a server with at least 1–2 GB of RAM and a couple of vCPUs depending on your workload.
- **Learn more & install:** Check the official documentation on [code-server Docs by Coder](https://google.com/goto?url=CAESRQHrOzAVzPjvNWy-Ev6FKawklEEhYcvDzXochMcKiU9zyIydENl6oRLHO3TPW2AgrjdotB_uDr9IUw0yrr-pgDOaUbAU3g).[[1]](https://google.com/goto?url=CAESRQHrOzAVzPjvNWy-Ev6FKawklEEhYcvDzXochMcKiU9zyIydENl6oRLHO3TPW2AgrjdotB_uDr9IUw0yrr-pgDOaUbAU3g)[[2]](https://google.com/goto?url=CAESUQHrOzAVFdAoWu6GqYv_1Q0c7fx7o_CLg7AW9KgJzP5t-RJygGAN7xbuQ_iwsbYXbZ8OCn_yEMSRMESyrZfcp3GfrufZqCTNCAllFKHxu51msA)[[3]](https://google.com/goto?url=CAEShgEB6zswFbut6NPL6uohHoxE-in08_PidmGM0b2aRcN9BDCE4S4PwJTRSc3ix6R599xRZbFC6tM2A3R0PPcRSIRnj8SQZXiL2v-6UiZGfa02qq9DpuuFiEy7V3ner3w_82OWTb9YyCZGkr4-9RBwd594LM72Np3BakY4IiLPXP_DrYN-JdWWmQ)[[4]](https://google.com/goto?url=CAESVAHrOzAVOWqqOZIfjN5C1siR8JHsaLBZqujVgS74AHOEgDnDEh1PQRIYDC6iZAS-4cLzGEhu74A6ikY6WGGUcg_ljnW-RFLeF8B7jgC6s4YkQXO03Q)[[5]](https://google.com/goto?url=CAESeAHrOzAVmcIAISR-5nbIMAdbm7OVBGXriIgJ0TXvVH0T9k3pfvqEIGVUcS7Sz6L2Vf9GKaKjvX87lJnRqfCC1oWy-4QsNR54N2y39Q_53LBgdOS2q9jX7AvrBv4q-yT7ynCVD8bHASmOtQbwL4eGZNrRYL4V-1c2JA)

- **What it is:** The orchestration platform built by the same creators as `code-server` . Instead of just launching a single instance, Coder provisions developer workspaces (using Terraform) on your own infrastructure (Kubernetes, AWS, bare-metal, or fully air-gapped environments).
- **Privacy & Control:** Ideal if you want isolated, ephemeral development containers that can connect to VS Code, JetBrains, or cursor via web/desktop. It has a zero-telemetry configuration option and supports fully air-gapped (no internet) networks.
- **Learn more:** Compare features and architecture on [Coder Solutions](https://google.com/goto?url=CAESUQHrOzAVFdAoWu6GqYv_1Q0c7fx7o_CLg7AW9KgJzP5t-RJygGAN7xbuQ_iwsbYXbZ8OCn_yEMSRMESyrZfcp3GfrufZqCTNCAllFKHxu51msA).[[1]](https://google.com/goto?url=CAESUQHrOzAVFdAoWu6GqYv_1Q0c7fx7o_CLg7AW9KgJzP5t-RJygGAN7xbuQ_iwsbYXbZ8OCn_yEMSRMESyrZfcp3GfrufZqCTNCAllFKHxu51msA)

- **What it is:** A containerized desktop environment accessible via a web browser (using KasmVNC) that gives you a full Alpine, Ubuntu, Fedora, or Arch desktop inside a browser tab.
- **Privacy & Control:** You can install any IDE you want (VS Code desktop, Neovim, etc.) inside the container. Because it runs purely in a Docker container on your hardware, no data leaves your server unless you explicitly configure it to.
- **Learn more & images:** Find setup guides on the LinuxServer.io ecosystem.[](https://google.com/goto?url=CAESiQEB6zswFS2SLYhlKahznNmcrclvugtBu-sWnxmawPjR7FiSZfSA9pQzkYt1h0soY18NqHCa22Fh8iQV1eYCH0PZ1iRil23KLJmR2ofvjPLYtce19sj9qQqXGvNXAPrmfMYcVUkduSrqmVNKhEuu462RJ0-CmPai24O4b0UuEqsTiktsNxDC70W3cg) [[1]](https://google.com/goto?url=CAESiQEB6zswFS2SLYhlKahznNmcrclvugtBu-sWnxmawPjR7FiSZfSA9pQzkYt1h0soY18NqHCa22Fh8iQV1eYCH0PZ1iRil23KLJmR2ofvjPLYtce19sj9qQqXGvNXAPrmfMYcVUkduSrqmVNKhEuu462RJ0-CmPai24O4b0UuEqsTiktsNxDC70W3cg)[[2]](https://google.com/goto?url=CAESVAHrOzAVOWqqOZIfjN5C1siR8JHsaLBZqujVgS74AHOEgDnDEh1PQRIYDC6iZAS-4cLzGEhu74A6ikY6WGGUcg_ljnW-RFLeF8B7jgC6s4YkQXO03Q)

- **What it is:** A container streaming platform that lets you spin up secure, isolated browser-based container sessions, including pre-built developer workspaces and IDEs.
- **Privacy & Control:** Highly secure and sandboxed. All execution happens on your host server, and you can lock it down so the containers have zero outbound internet access.
- **Learn more:** Explore the platform on Kasm Workspaces.[](https://google.com/goto?url=CAESiQEB6zswFS2SLYhlKahznNmcrclvugtBu-sWnxmawPjR7FiSZfSA9pQzkYt1h0soY18NqHCa22Fh8iQV1eYCH0PZ1iRil23KLJmR2ofvjPLYtce19sj9qQqXGvNXAPrmfMYcVUkduSrqmVNKhEuu462RJ0-CmPai24O4b0UuEqsTiktsNxDC70W3cg) [[1]](https://google.com/goto?url=CAESiQEB6zswFS2SLYhlKahznNmcrclvugtBu-sWnxmawPjR7FiSZfSA9pQzkYt1h0soY18NqHCa22Fh8iQV1eYCH0PZ1iRil23KLJmR2ofvjPLYtce19sj9qQqXGvNXAPrmfMYcVUkduSrqmVNKhEuu462RJ0-CmPai24O4b0UuEqsTiktsNxDC70W3cg)

To help narrow down the best fit, tell me:

• Are you deploying this for a single user or a team?
• What is your hosting environment (Docker on a home server/VPS vs Kubernetes)?

If you need a cloud-based development environment that remains entirely under your control—running on your own hardware or private cloud with zero telemetry or code leaking to third parties—several robust, open-source options fit the bill.

The top self-hosted cloud IDE solutions, ranked by architecture and use case, include:

• code-server
  • What it is: VS Code running on a remote server, accessible entirely through your web browser.
  • Privacy/Self-hosting: Fully open-source and self-hosted. It does not send your source code or telemetry anywhere unless you explicitly install a telemetry-heavy extension.
  • How to run: Easily spun up via a quick install script or containerized environments. You can check out the code-server GitHub Repository for instructions.
• Coder (v2)
  • What it is: An enterprise-grade, self-hosted provisioning platform that spins up reproducible development environments (Docker containers, Kubernetes pods, or remote VMs) managed via Terraform.
  • Privacy/Self-hosting: Designed strictly for self-hosting on your own infrastructure (on-prem or cloud VPCs). It acts as the control plane while letting you connect via your preferred editor (VS Code, JetBrains, or web-based options) over a secure WireGuard tunnel.
  • How to run: Deployable on your own servers; details and source code are available at the Coder GitHub Repository.
• Eclipse Theia
  • What it is: A flexible, extensible, open-source cloud and desktop IDE framework modeled similarly to VS Code. Unlike simple VS Code wrappers, Theia is built from the ground up to be vendor-neutral and natively supports multi-tenant cloud architectures.
  • Privacy/Self-hosting: Highly modular and easily containerized via Docker/Docker Compose to run completely isolated on your own local server or private cluster.
  • How to run: Community guides and deployment patterns are outlined on the Eclipse Theia Website and its Theia IDE GitHub Repository.
• OpenVSCode Server
  • What it is: A version of VS Code maintained by Gitpod that runs as a server on a remote machine, giving you a pure browser-based VS Code experience using the exact upstream architecture intended for cloud backends.
  • Privacy/Self-hosting: Runs locally or on a private server with community-maintained container images (such as the linuxserver/openvscode-server Docker Hub page).

To help narrow down the ideal choice, let me know:

• Are you planning to host this on a local home server/homelab or a private cloud VPS (like AWS/Hetzner)?
• Do you prefer a single-container setup like code-server or a multi-user orchestration platform like Coder?

Yes. If your requirement is self-hosted + browser-based + source code stays under your control, there are several strong options.

Best choices

1. Coder — my overall recommendation

Coder is specifically designed as a self-hosted cloud development environment platform. You run the control plane and workspaces on infrastructure you control, with workspaces able to run as Docker containers, Kubernetes pods, or VMs.

It also supports VS Code, JetBrains IDEs, SSH, and browser-based access. Its documentation describes the platform as open source and auditable.

Important: self-hosting Coder doesn't automatically mean nothing leaves your network. If you use cloud-hosted AI models, GitHub, external extension registries, package repositories, etc., those services can still receive data. For maximum isolation, configure those dependencies to use internal/self-hosted services.

2. code-server — simplest option

If you basically want "VS Code running on my own server, accessible through a browser," this is probably the easiest answer.

It's open source, self-hosted, and runs VS Code in the browser. It can be installed on an ordinary Linux server with relatively modest requirements.

It also has a --disable-telemetry option, and its documentation notes that its self-hosted web views don't call Microsoft's servers.

For a single developer or small setup, I'd choose this over Che.

3. Eclipse Che — best for Kubernetes

Che is a Kubernetes-native cloud IDE. Its workspaces run as Kubernetes/OpenShift containers, and the documentation explicitly states that source code is kept on the cluster.

It's particularly attractive if you already operate Kubernetes and want isolated, reproducible development environments for a team.

What I'd pick

• One person / homelab: code-server
• Small-to-large development team: Coder
• Enterprise Kubernetes environment: Eclipse Che
• Air-gapped environment: Coder or Che, but configure private Git, private package registries, private extension registries, and local LLMs as well.

One subtle point: "self-hosted" isn't sufficient to guarantee zero third-party code transmission. The IDE itself can stay entirely on your infrastructure while extensions, telemetry, AI assistants, Git providers, package managers, or update mechanisms communicate externally.

If your requirement is literally "the server must be capable of running with zero outbound Internet access", I can narrow this down to the best air-gapped cloud IDEs and show exactly what needs to be disabled or self-hosted.

Yes. If your requirement is “the IDE and source code run entirely on infrastructure I control, with no code sent to a SaaS vendor”, there are several good options.

My top choices

1. Coder + code-server — my recommendation

Coder is specifically designed for self-hosted cloud development environments. You run Coder on your own infrastructure and create workspaces on VMs, Kubernetes, or Docker. It supports browser-based VS Code through code-server, as well as JetBrains and other IDEs.

Importantly, Coder can be deployed fully air-gapped/on-premises, so you can keep source code and development infrastructure under your control.

For a particularly strict setup, I'd use:

Browser → Coder → private VM/container → code-server

and configure the environment with no outbound internet access except whatever package registries/internal services you explicitly permit.

2. code-server — simplest

code-server is essentially VS Code running in your browser. You install it directly on a Linux server and access it over HTTPS.

It also has a --disable-telemetry option.

This is a great choice if you just want “VS Code on my own server” rather than a platform managing many developer environments.

3. Eclipse Che — best if you already run Kubernetes

Eclipse Che is Kubernetes-native and puts the IDE, dependencies, runtime, and project source into Kubernetes workspaces. It explicitly supports installation on private Kubernetes clusters and restricted/air-gapped environments.

Che's documentation specifically says source code stays on the cluster, making it attractive for security-sensitive deployments.

One important caveat

Self-hosted doesn't automatically mean “nothing ever leaves the network.” IDE extensions, package managers, Git integrations, language servers, and AI assistants can independently make outbound connections.

If your requirement is genuinely zero third-party code exposure, I'd build the environment with:

• Coder or Che hosted on your infrastructure
• code-server/VS Code OSS
• private Git server
• internal package mirrors/registries
• Open VSX or an internally mirrored extension repository
• outbound firewall rules denying Internet access by default
• no cloud AI coding assistants
• telemetry disabled wherever possible
• internal DNS/proxy with logging and allowlists

For a small team, I'd choose Coder + code-server. For one developer, I'd choose code-server alone. For an existing Kubernetes platform, I'd choose Eclipse Che.

If you want a browser-accessible cloud IDE that runs entirely on your own hardware or private cloud—guaranteeing that your source code, metadata, and keystrokes never leave your network—several robust, open-source options fit the bill.

Here are the best self-hosted cloud IDEs available:

• code-server (VS Code in the Browser) : This runs code-server on a remote server or local machine, allowing you to access a full, native Visual Studio Code instance directly through any web browser. It supports almost all standard VS Code extensions, handles authentication via passwords or hashed tokens, and executes everything locally on your hardware.
• Coder: Coder is an open-source infrastructure-as-code platform that provisions remote, containerized development workspaces. Rather than just serving a single static editor, it lets you orchestrate full developer environments on your own Kubernetes clusters or private cloud servers, attaching VS Code or Theia IDE to them securely.
• Eclipse Che: Eclipse Che is an enterprise-grade, open-source Kubernetes-native cloud IDE and workspace server. It spins up developer workspaces inside isolated containers complete with runtimes, toolchains, and editors, giving large teams or solo operators total sovereignty over their execution pipeline.
• Atheos : If you need an ultra-lightweight, low-resource environment that doesn't require massive container setups or heavy server footprints, Atheos is a clean, modern, PHP-based web IDE framework (forked and modernized from Codiad) that runs smoothly on modest virtual private servers or homelabs.
• JupyterLab : For data science, machine learning, or heavy interactive Python/Notebook workflows, JupyterLab provides a powerful browser-based execution and editing environment that runs natively on your machine or private server with zero telemetry.

To help narrow down the best choice, tell me:

• What is your target host environment (a local machine, a homelab server, or a cloud VPS)?
• Do you need multi-user support with role-based access, or is this strictly for personal use?

If you want a browser-accessible, cloud-style development environment that runs entirely on your own infrastructure (VPS, home server, or private cloud) and keeps 100% of your code and telemetry private, there are three top-tier open-source projects that fit the bill.

1. code-server (by Coder)

• What it is: VS Code running on a remote server, accessible through any modern web browser.
• Privacy & Self-Hosting: Fully self-hosted via Docker or a direct install script. It runs entirely on your hardware, and telemetry can be completely disabled or pointed internally.
• Best for: Individuals or small teams who want a straightforward "VS Code in the browser" experience with robust support for extensions and port forwarding.
• Get started: Check the code-server GitHub Repository or follow the official installation steps in the code-server Documentation.

2. OpenVSCode Server (by Gitpod)

• What it is: A version of upstream VS Code specifically patched to run on a remote server and accessed via the browser, aiming for a close 1:1 parity with desktop VS Code behavior.
• Privacy & Self-Hosting: Open-source and containerized, meaning you can spin it up on your own private server or local network without any external data-sharing.
• Best for: Developers who prefer a cleaner upstream implementation of VS Code in the browser that minimizes extra custom wrappers.
• Get started: Review the architecture and container images on the OpenVSCode Server GitHub Repository.

3. Coder (Enterprise / Open Source platform)

• What it is: An Infrastructure-as-Code (IaC) provisioning platform that manages entire development workspaces (using Terraform and Docker/Kubernetes). It automatically spins up environments and serves code-server or lets you connect via your local desktop IDE.
• Privacy & Self-Hosting: Designed for complete control over private clouds or on-prem hardware, supporting fully air-gapped networks where external connections (like the standard Microsoft Extension Marketplace) are blocked or replaced with local mirrors.
• Best for: Power users, homelabs, or teams managing multiple dynamic environments across a private infrastructure.
• Get started: Explore the platform architecture on the Coder Documentation or deploy via the Coder GitHub Repository.

If you can tell me where you plan to host it (e.g., a local home server, a dedicated VPS, or Kubernetes) and whether you need it for just yourself or a team , I can help you choose the right deployment method and configuration.

Yes. If your requirement is “the IDE runs on infrastructure I control, and source code does not get sent to a SaaS provider,” there are several good options.

My top recommendation: code-server

code-server is essentially VS Code running in your browser, but hosted on your own Linux server. Your files, terminal, builds, and development environment stay on that server. It is open source and can be installed directly or with Docker.

Importantly for your requirement, code-server specifically supports self-contained web views that don't call Microsoft's servers, configurable telemetry, and your own extension marketplace.

You can make the setup even more isolated:

Browser → HTTPS → your server → code-server → your source code

No third-party IDE SaaS is required.

For a team: Coder

Coder is the better choice if you need multiple developers, authentication, ephemeral workspaces, Kubernetes/VM provisioning, RBAC, etc. Coder is explicitly self-hosted and designed to run on infrastructure you control.

It can provide code-server as the browser IDE inside each workspace.

One important caveat: Coder has telemetry enabled by default, although it can be disabled with CODER_TELEMETRY_ENABLE=false.

Other option: Eclipse Theia

Eclipse Theia is another open-source browser IDE designed for self-hosting. It isn't a modified VS Code; it's a separate IDE built around the same Monaco editor and VS Code-compatible extension concepts.

What I'd choose

For one person, I'd use code-server. For a company/team, I'd use Coder + code-server.

One distinction is important: “self-hosted IDE” doesn't automatically mean “nothing ever leaves the server.” GitHub, package registries, extension marketplaces, language servers, AI APIs, crash reporting, and telemetry can still make outbound connections depending on configuration. If you mean strict air-gapped operation with zero outbound network access, I can recommend a specific architecture and configuration for that too.

If you want a browser-accessible cloud IDE that runs entirely on your own infrastructure and keeps your code 100% private, you have a few great open-source and self-hostable options.

Here are the top choices depending on whether you want a single-user environment or an infrastructure-managed multi-container setup:

• code-server (by Coder) : Run VS Code on any server and access it through any browser. It packages Visual Studio Code so it runs on a remote machine, allowing you to use your favorite extensions, keybindings, and terminal from anywhere without your code leaving your hardware. It is ideal for a dedicated development VPS or home lab.
• Eclipse Theia : An extensible, open-source cloud and desktop IDE framework designed from the ground up to run natively in browsers. It looks and behaves very much like VS Code (and supports VS Code extensions), but it is architected specifically as a multi-language cloud platform that you can dockerize and self-host.
• Coder : An enterprise-grade, self-hosted orchestrator that provisions reproducible developer environments via Terraform on your own infrastructure (AWS, GCP, bare metal, or air-gapped networks). It lets your team connect any IDE (VS Code, JetBrains, Cursor, Zed) via the browser or desktop while keeping code securely locked inside your network.
• DevPod : A client-side tool that lets you spin up reproducible, isolated dev environments in any infrastructure provider (including local Docker or a remote private server) without needing a centralized server backend. It connects cleanly to VS Code or other local editors.

To help narrow down the ideal setup, let me know:

• Are you looking for a single-user environment (like on a personal VPS) or a multi-user/team setup?
• What infrastructure do you plan to host it on (a local machine, a rented VPS, or Kubernetes)?

If you need a self-hosted cloud IDE where your source code stays on your own infrastructure, look for solutions that run the editor, workspace, and extensions on your server rather than using a hosted SaaS IDE.

Good options:

My recommendations by use case

Personal/private development server

• Use code-server.
• Run it in Docker on a VPS, homelab server, or internal machine.
• Put it behind a VPN or reverse proxy with authentication.
• Disable telemetry where applicable and review extensions before installing them. code-server specifically focuses on a self-hosted VS Code experience and includes changes aimed at avoiding calls to Microsoft services for web views.

Small engineering team

• Use Coder’s platform or Gitpod self-hosted.
• Add:
  • SSO (OIDC/SAML)
  • per-user containers
  • isolated workspaces
  • audit logging
  • private Git hosting

Maximum control / air-gapped environment

• Use:
  • OpenVSCode Server or code-server
  • local Git server (for example, GitLab self-managed)
  • private container registry
  • internally mirrored extension repositories

Things to verify before deploying

A "self-hosted" IDE can still leak data if you don't check:

• Extensions — some extensions send telemetry or use external APIs.
• AI assistants — disable cloud AI features unless you explicitly want code sent to a provider.
• Package managers — builds may contact public registries.
• Git remotes — ensure repositories point only to approved servers.
• Browser access — protect the IDE endpoint with HTTPS and authentication.

A strong private setup is often:

Browser → VPN/reverse proxy → self-hosted IDE container → private Git server → private build runners

That architecture keeps the code path inside your infrastructure.