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

Yes. If your requirement is “the IDE and source code stay on infrastructure I control, with no mandatory code transmission to a SaaS provider,” there are several good options.

My top picks

1. code-server — simplest

• Runs VS Code in your own Linux server/container.
• Access it through a browser from anywhere.
• Open source and self-hosted.
• Its documentation specifically notes self-contained web views that don't call Microsoft's servers and supports disabling telemetry.
• Best if you're an individual or small team and don't need elaborate workspace orchestration.
• You can run it completely inside your LAN/VPN.

coder.com 2. Coder — best for a team

• A self-hosted platform for provisioning complete development environments.
• Supports Docker, Kubernetes, VMs, etc.
• Developers can use VS Code, JetBrains IDEs, Vim, and others.
• Workspace connections use a secure WireGuard tunnel.
• Particularly attractive if you want centralized authentication, per-developer environments, templates, and lifecycle management.

coder.com 3. Eclipse Che — best for Kubernetes/enterprise

• Kubernetes-native cloud development environments.
• Source code and development environments run in your Kubernetes cluster rather than on developers' machines.
• Supports air-gapped/offline deployments and can use a self-hosted Open VSX registry, which is useful if you want to eliminate external extension services too.
• More complicated to operate than code-server.

What I'd choose

Important distinction: self-hosting the IDE doesn't automatically mean nothing leaves your network. Extensions, package managers, Git remotes, AI assistants, crash reporting, update checks, and language servers can independently make network requests.

If you need strictly zero third-party communication, I'd set up something like:

Browser → WireGuard/Tailscale VPN → your server → code-server → local Git/package/extension mirrors

and firewall the IDE's outbound traffic. For the strongest isolation, use an air-gapped environment; Eclipse Che explicitly supports this model.

If you tell me whether this is for yourself or a team, and whether you have Docker, Kubernetes, or just a Linux server, I can recommend a specific architecture and setup.

When you want a fully self-hosted cloud IDE that guarantees zero code telemetry and zero third-party data transmission, you need a solution where both the compute environment and the interface live entirely on your own infrastructure (local server, home lab, or private cloud).

The top self-hosted, privacy-respecting cloud IDE options available fit different setup complexities:

1. code-server (by Coder)
   • What it is: Running VS Code in the browser by spinning up a backend instance on your own server. It renders a full VS Code interface inside any web browser.
   • Privacy & Telemetry: Completely self-hosted. It does not send your source code to third parties. However, Microsoft’s default telemetry/extension marketplace tracking can still phone home unless explicitly disabled or configured with environment flags.
   • Best for: Individuals or teams who want the exact look, feel, and extension ecosystem of VS Code on a remote private server.
   • Get started via the code-server documentation.
2. Eclipse Theia / Theia IDE
   • What it is: An open-source, vendor-neutral extensible IDE framework designed specifically for the cloud and desktop (built on the Monaco editor, like VS Code, but not a direct fork).
   • Privacy & Telemetry: Theia IDE explicitly states it sends no telemetry on your code, prompts, or data, making it heavily favored for enterprise data-sovereignty and strict privacy requirements. It connects to the open-source Open VSX registry rather than Microsoft's proprietary marketplace.
   • Best for: Maximum open-source purity and zero built-in telemetry out of the box.
   • Explore the project at Theia IDE.
3. Coder (v2)
   • What it is: An infrastructure orchestration platform (also by the creators of code-server) that provisions fully customizable Cloud Development Environments (CDEs) using Terraform. It can spin up workspaces in Docker containers, Kubernetes pods, or remote VMs that you control.
   • Privacy & Telemetry: Entirely self-hosted on your infrastructure with air-gapped support. It handles workspace security via secure WireGuard tunnels and keeps all data local.
   • Best for: Power users, homelabs, or organizations wanting to dynamically manage ephemeral developer environments on their own hardware.
   • Check out the architecture on Coder GitHub.
4. Eclipse Che
   • What it is: A Kubernetes-native workspace server that provisions developer workspaces and can inject various IDEs (including Theia or VS Codium) into the browser.
   • Privacy & Telemetry: Fully open-source and self-hosted on your own orchestrator cluster.
   • Best for: Teams running a local Kubernetes/OpenShift cluster who need multi-user cloud workspaces.

To help narrow down the best fit, tell me:

• Will this run on a single local server/VPS or a Kubernetes cluster?
• Do you prefer a straightforward VS Code-in-the-browser experience or an orchestrator that manages ephemeral containers?

If you need a fully self-hosted cloud IDE that keeps your code strictly on your own infrastructure and avoids leaking telemetry or code data to third parties, there are three primary open-source/self-hosted solutions that fit the bill.

Top Self-Hosted Cloud IDE Options

1. code-server (by Coder)
   • What it is: VS Code running on a remote server, accessible via any browser. It removes calls to Microsoft's telemetry and extension marketplace servers by default.
   • Privacy/Telemetry: Completely self-hosted. It has optional telemetry for infrastructure usage, but this can be completely disabled via environment variables (CODER_TELEMETRY_ENABLE=false ) or CLI flags. Your source code never leaves your server.
   • Get started: Check out the official repository and docs via code-server on GitHub.
2. Coder (Enterprise / Open Source Control Plane)
   • What it is: An infrastructure orchestration platform that provisions remote development workspaces (Docker, Kubernetes, or VMs) using Terraform. It allows you to spin up fully isolated, browser-accessible IDE environments.
   • Privacy/Telemetry: Designed for air-gapped and high-security enterprise environments with zero external dependencies. Telemetry can be completely disabled.
   • Get started: Explore architecture guides at Coder Solutions.
3. Eclipse Theia (Cloud/Browser version)
   • What it is: An extensible, open-source framework closely resembling VS Code's architecture, built specifically to run natively as a cloud or desktop application.
   • Privacy/Telemetry: Theia IDE explicitly enforces a strict no-telemetry policy regarding your code, prompts, or AI actions, allowing direct connection to local/self-hosted models without third-party proxy routing.
   • Get started: Learn more about architecture and deployment at Theia IDE.

To help narrow down the best choice, tell me:

• Are you deploying this for just yourself on a single server (like a homelab/VPS) or for a team?
• Do you want it deployed via Docker, Kubernetes , or bare metal?

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

My top choices

• Coder — best overall for teams. Coder is explicitly self-hosted and can provision workspaces on your own VMs, Kubernetes, or Docker. It gives you a browser IDE while keeping the development environment on your infrastructure.
• code-server — best for a simple setup. It's essentially VS Code running on your own Linux server and accessed through a browser. It's open source and self-hosted; its documentation specifically notes that its web views can avoid calls to Microsoft's servers.
• Eclipse Che — best for Kubernetes/enterprise environments. Che runs IDEs and workspaces as Kubernetes pods, keeps source code on your cluster, supports air-gapped deployments, and can use a self-hosted Open VSX registry.

What I'd choose

One important distinction: self-hosting the IDE doesn't automatically mean zero third-party network traffic. Extensions, package managers, Git remotes, container registries, telemetry, and AI assistants can still contact external services. For a genuinely isolated environment, I'd disable telemetry, use an internal Git server/package registry/container registry, and—if necessary—run an internal extension registry. Eclipse Che explicitly supports air-gapped operation and self-hosted Open VSX.

If you tell me whether this is for one developer, a small team, or an enterprise, and whether you have Docker/Kubernetes/a Linux VM, I can recommend the simplest architecture and give you the exact setup steps.

Coder and code-server are the leading self-hosted cloud IDE solutions that run entirely on your own infrastructure and keep your source code completely private.

Because they operate on your local server, private cloud, or on-premise hardware, no telemetry, source code, or metadata is sent to third-party corporate servers unless you explicitly install an extension that does so.

Top Self-Hosted Cloud IDE Options

• code-server : Runs VS Code on a remote server accessible via any web browser. It is lightweight, straightforward to deploy via Docker or a standalone binary, and retains the full extension ecosystem and look-and-feel of desktop VS Code.
• Coder : An enterprise-grade orchestrator that provisions and manages developer workspaces (powered by VS Code or JetBrains) on your own infrastructure. It treats infrastructure as code and lets teams spin up secure, isolated development environments on private clouds or bare metal.
• Eclipse Che : A Kubernetes-native cloud IDE that provides developer workspaces mapped directly to container pods. It is ideal for larger teams needing centralized governance inside an on-premise Kubernetes or OpenShift cluster.
• Eclipse Theia : An extensible open-source framework to build multi-platform IDEs supporting both desktop and cloud (browser) architectures using web technologies. It serves as the foundation for various custom enterprise cloud development environments.
• DevPod : A client-side tool that provisions reproducible developer environments inside any underlying infrastructure (Docker, Kubernetes, or remote SSH) using standard IDEs like VS Code or Cursor without storing state or code on third-party clouds.

Comparison of Self-Hosted Solutions

Would you like help choosing between code-server and Coder , or do you need a step-by-step guide on deploying one via Docker on your server?

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

My top picks

• code-server — best for a simple setup. It runs VS Code in your browser on your own Linux server. It is open source, self-hosted, and supports disabling telemetry. Its documentation specifically notes that its web views can be made self-contained rather than calling Microsoft's servers.
• Coder — best for a team. It provisions isolated development environments on your own VMs, Kubernetes, Docker, etc., and provides browser-based IDE access. It also supports air-gapped deployments.
• Eclipse Che — best if you already run Kubernetes. Workspaces run as Kubernetes pods on your cluster, with source code remaining on the cluster. Che explicitly supports air-gapped environments and private installations.

What I'd choose

One important distinction: self-hosted does not automatically mean “nothing ever contacts a third party.” Your IDE may still download extensions, packages, container images, Git repositories, etc. If you need a genuinely no-code-leaves-the-network environment, I'd configure it with an internal Git server, internal package/container registries, an internal VS Code/Open VSX extension registry, telemetry disabled, and outbound network access blocked from the workspace.

If you tell me (1) single user vs team, (2) Docker/VM/Kubernetes, and (3) whether the server can have Internet access, I can recommend a specific architecture and give you a minimal deployment configuration.

The best self-hosted cloud IDEs that run entirely on your own infrastructure and keep your code completely private are code-server, Coder , and Eclipse Che.

Running a self-hosted cloud environment ensures that your source code, credentials, and project data never leave your private server or network.

Top Self-Hosted Cloud IDE Options

Key Benefits of Self-Hosted Options

• Data Privacy: Code stays local to your server, avoiding third-party SaaS platforms or external cloud analysis.
• Full Control: You manage access tokens, user authentication, and resource limits directly.
• Familiar Interface: Tools like code-server provide the full VS Code extension marketplace and shortcut layout inside any modern web browser.

If you'd like to narrow this down, let me know:

• Will this run on a single server or a Kubernetes cluster?
• Do you need multi-user management with role-based access control?

If your requirement is:

• Browser-accessible cloud IDE
• Runs on your own server/VPS/on-prem hardware
• Source code never leaves your infrastructure
• No dependency on a third-party hosted IDE provider

then these are the strongest options:

1. Coder code-server — best general choice

What it is: A self-hosted VS Code experience that runs in your browser. Your repositories, terminal, extensions, and runtime stay on your machine.

Good fit for:

• Individual developers
• Small teams
• Private servers
• Homelabs
• Internal development environments

Typical deployment:

• Docker container on a Linux server
• Behind your own VPN/reverse proxy
• Accessed through a browser

Privacy posture:

• Your code stays on your host.
• You control networking, backups, authentication, and telemetry settings.
• Be careful with extensions: some VS Code extensions may contact external services.

Pros

• Familiar VS Code interface
• Huge ecosystem
• Integrated terminal
• Works well with containers
• Easy to deploy

Cons

• Some Microsoft VS Code marketplace features/extensions may not work exactly like desktop VS Code.

---

2. OpenVSCode Server

This is closer to upstream VS Code's browser architecture. It runs VS Code on your own machine and exposes it through a browser.

Good fit for:

• Teams building their own cloud development platform
• Organizations wanting a more upstream VS Code approach

Pros

• Open-source
• VS Code-based
• Container-friendly

Cons

• Less "batteries included" than code-server
• You may need to build more of the surrounding platform yourself

---

3. Eclipse Che

Good for larger engineering organizations.

Good fit for:

• Kubernetes environments
• Many developers
• Standardized developer workspaces

Pros

• Designed around reproducible workspaces
• Strong enterprise/team model

Cons

• More operational complexity than a single-user IDE

---

4. Theia IDE

A browser IDE framework with VS Code-like concepts.

Good fit for:

• Building a customized internal IDE
• Organizations that want to embed or extend an IDE experience

Cons

• More of a platform/framework than a drop-in replacement

---

Recommended private setup

For most people who want "my own cloud IDE and nobody else sees my code":

Your laptop browser
        |
     HTTPS/VPN
        |
 Reverse proxy (Caddy/Nginx)
        |
   code-server container
        |
   Your Git repos + tools

Security checklist:

• Use a VPN such as WireGuard or Tailscale rather than exposing the IDE publicly.
• Put the IDE behind HTTPS.
• Disable telemetry where applicable.
• Review installed extensions.
• Use separate containers/workspaces for untrusted projects.
• Keep backups encrypted.

For a single developer or small team, I would start with code-server in Docker on your own VM or server. It is the closest match to a private, self-hosted replacement for GitHub Codespaces.

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.[1][2][3][4][5]

- **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.[1]

- **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. [1][2]

- **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. [1]

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)?