[Feature Request] Native WSL Remote Integration for Claude Code Desktop on Windows

Resolved 💬 22 comments Opened Apr 17, 2026 by matheuspimentaa Closed Jul 13, 2026

Preflight Checklist

  • [x] I have searched existing requests and this feature hasn't been requested yet
  • [x] This is a single feature request (not multiple features)

Problem Statement

Summary

Add native WSL (Windows Subsystem for Linux) remote integration support to Claude Code Desktop on Windows, similar to the "Remote - WSL" approach used by VS Code. The goal is to allow Claude Code to connect to a WSL distribution and run the entire development environment — including the Claude Code agent, its commands, the integrated terminal, and any spawned processes — inside WSL, rather than running on Windows and simply reading files from the \\wsl$\ or \\wsl.localhost\ network share.

Problem / Motivation

Currently, when a developer opens a WSL project in Claude Code Desktop on Windows, the IDE effectively runs on the Windows side and accesses the Linux filesystem through the \\wsl$\ / \\wsl.localhost\ UNC path. This leads to several practical issues for developers whose real working environment is WSL (Ubuntu, Debian, Arch, etc.):

  1. Wrong shell / wrong toolchain. The integrated terminal and any commands executed by Claude Code (tests, builds, package managers, git hooks, linters, formatters, etc.) run under Windows using PowerShell/cmd, instead of the native Unix shell (bash/zsh/fish) inside WSL. Tooling installed only inside WSL (nvm, pyenv, asdf, rbenv, system packages via apt, Docker inside WSL, etc.) is not available or behaves inconsistently.
  1. Path and line-ending mismatches. Tools end up seeing Windows-style paths (\\wsl.localhost\Ubuntu\home\user\project) instead of native Linux paths (/home/user/project). This breaks scripts, Makefiles, Docker volume mounts, symlinks, file watchers, and anything that depends on POSIX semantics or case-sensitive filesystems.
  1. Performance penalties. Reading/writing files across the 9P protocol from Windows into the WSL filesystem is significantly slower than operating natively inside WSL. For large repositories, running Claude Code tasks (indexing, grep-like searches, test runs) is noticeably slower and can hit file-watch limits.
  1. Permissions and environment drift. File permissions, UID/GID ownership, environment variables, $PATH, $HOME, SSH agents, GPG agents, and shell profiles (.bashrc, .zshrc, .profile) defined inside WSL are not respected when Claude Code runs from the Windows side. This causes features like git signing, SSH-based remotes, or credential helpers to fail or behave differently than in the developer's real shell.
  1. Mismatch with developer expectations. Many developers use WSL precisely because their project targets Linux (containers, CI, production). They expect Claude Code's agent to reason about and operate on the project in the exact same environment their Linux tooling uses — not through a Windows-side proxy.

Proposed Solution

Introduce a first-class "Connect to WSL" mode in Claude Code Desktop for Windows, conceptually equivalent to VS Code's Remote - WSL:

  • A command / entry point such as "Claude Code: Connect to WSL..." that lets the user pick an installed WSL distribution (e.g., Ubuntu-22.04, Debian) and a target folder using Linux paths (/home/user/project).
  • When connected, Claude Code installs and runs a lightweight remote server component inside the chosen WSL distribution. The desktop app on Windows becomes a thin UI client that talks to this server over a local channel (e.g., localhost socket / named pipe / stdio through wsl.exe).
  • All "backend" work happens inside WSL:
  • The Claude Code agent process and its tool executions run inside WSL.
  • The integrated terminal is a real Unix shell (user's default login shell inside WSL, honoring /etc/passwd and shell rc files).
  • File reads/writes, searches, diffs, and edits use the native Linux filesystem at Linux paths.
  • Commands invoked by Claude Code (build, test, run, lint, format, git, package managers, Docker, etc.) execute inside WSL, using the Linux $PATH and environment.
  • Opening a project via \\wsl$\... or \\wsl.localhost\... should detect the WSL origin and offer to reopen the folder in WSL remote mode.
  • Support opening a WSL folder directly from the Linux side via a CLI entry point (e.g., something analogous to code . but for Claude Code) so users can run it from inside their WSL shell and have the desktop UI attach to that session.
  • Respect the user's WSL configuration: default distribution, default user, /etc/wsl.conf, environment variables, and shell startup files.
  • Provide clear status indicators in the UI showing: "Connected to WSL: Ubuntu-22.04", current Linux working directory, and the shell being used.

User Experience Goals

  • From the user's perspective, once connected, Claude Code "is" running in Linux: terminals are bash/zsh, paths are /home/user/..., tools are the ones installed via apt, brew (linuxbrew), nvm, pyenv, etc.
  • The PowerShell/cmd environment on Windows is not involved in executing project commands.
  • Reconnecting to a recently used WSL workspace should be a single click.

Alternatives Considered

  • Current behavior (accessing \\wsl.localhost\... from Windows). Works for simple editing but fails for serious development due to the issues listed above.
  • Running Claude Code entirely inside WSL as a Linux app (e.g., via WSLg). Viable for some users, but adds friction (GUI-in-WSL setup, different install path, separate updates) and does not match the expected Windows-desktop experience. A remote model gives the best of both: native Windows UI + native Linux backend.
  • Manually launching Claude Code CLI inside WSL and a separate Windows UI. Fragmented workflow, no unified UX, and hard to keep in sync with the desktop app.

Additional Context

  • Prior art: VS Code's Remote - WSL extension, JetBrains IDEs' WSL backend support, and Cursor's WSL remote mode. These are widely adopted precisely because developers want the IDE/agent to operate natively inside WSL.
  • This feature would be especially valuable for users working on Linux-first stacks (Node.js, Python, Go, Rust, Ruby, Docker/Kubernetes, ML workflows) from a Windows machine.
  • Ideally, this should also play well with Claude Code's agent capabilities, so that when the agent runs commands, it does so inside WSL with the correct shell, environment, and filesystem semantics — not through PowerShell.

Impact

Enabling native WSL remote integration would make Claude Code Desktop a genuinely viable primary tool for Windows-based developers whose real environment is Linux, eliminate an entire class of path/shell/environment bugs, significantly improve performance on WSL projects, and bring parity with other modern IDEs that already support this workflow.

Proposed Solution

Add a first-class "Connect to WSL" mode to Claude Code Desktop on Windows, analogous to VS Code's Remote - WSL extension.

Desired user flow:

  1. In Claude Code Desktop, the user opens a command palette / menu entry such as "Claude Code: Connect to WSL..." and picks an installed WSL distribution (e.g., Ubuntu-22.04, Debian) and a target Linux folder (e.g., /home/user/projects/my-app).
  2. Claude Code installs (on first use) and runs a lightweight remote server component inside the selected WSL distro. The Windows desktop app acts as a UI client talking to that server over a local channel (stdio via wsl.exe, a UNIX socket, or a localhost port).
  3. From that point on, the entire Claude Code backend runs inside WSL:
  • The Claude Code agent process runs in Linux.
  • The integrated terminal is the user's default Unix shell (bash/zsh/fish), honoring .bashrc, .zshrc, /etc/profile, etc.
  • File reads, writes, searches, and diffs happen on the native Linux filesystem using Linux paths (/home/user/...), not \\wsl.localhost\....
  • Every command Claude Code invokes (tests, builds, linters, formatters, git, npm, pnpm, pip, poetry, cargo, go, docker, etc.) is executed inside WSL with the Linux $PATH and environment — never through PowerShell or cmd.
  1. A status indicator in the UI clearly shows the remote context, e.g. WSL: Ubuntu-22.04 — /home/user/projects/my-app — shell: zsh.
  2. A CLI entry point from inside WSL (similar to VS Code's code .) lets the user run e.g. claude . in their Linux shell and have the Windows desktop UI attach to that WSL session.
  3. Opening a project via \\wsl$\... or \\wsl.localhost\... triggers a prompt: "This folder is inside WSL. Reopen in WSL?" — one click switches to remote mode.
  4. Recent WSL workspaces are remembered and can be reopened in one click, reconnecting to the correct distro and path.

Key requirement: when the user interacts with Claude Code in this mode, it must feel exactly like running Claude Code natively inside Linux — the Windows side is only responsible for rendering the UI and forwarding input/output.

Alternative Solutions

  1. Current behavior — opening WSL folders via \\wsl$\ / \\wsl.localhost\ from Windows. Claude Code runs on Windows and only reaches into WSL through the 9P network share. Commands execute in PowerShell/cmd, paths are Windows UNC paths, and WSL-installed toolchains (nvm, pyenv, apt packages, Docker in WSL, etc.) are not properly available. This is the scenario this feature request wants to replace.
  1. Running Claude Code entirely inside WSL as a Linux GUI app (via WSLg). Technically possible for some users, but requires a separate Linux install of Claude Code, different update channel, and GUI-in-WSL setup. It also breaks the "Windows desktop app" UX that most Windows users expect. Not a good general solution.
  1. Using Claude Code CLI inside WSL plus a separate Windows UI. Fragmented workflow: two disconnected surfaces, no unified session, harder to keep versions and settings in sync, and poor discoverability for new users.
  1. Third-party wrappers / manual scripts that invoke wsl.exe for specific commands. Fragile, doesn't cover the full agent surface (terminal, file I/O, watchers, subprocesses), and every user has to re-implement it. Should be solved once, officially, inside Claude Code.

A proper remote-WSL architecture (like VS Code's) is the only alternative that cleanly solves all of these issues at once.

Priority

Critical - Blocking my work

Feature Category

Other

Use Case Example

Scenario: Full-stack developer on Windows targeting Linux

  1. I use Windows 11 as my daily OS but all my development happens inside WSL2 (Ubuntu 22.04), where I have nvm, pnpm, pyenv, poetry, Docker (Linux engine), and my SSH/GPG keys configured. My project lives at /home/matheus/projects/my-app and targets a Linux production environment.
  2. I open Claude Code Desktop on Windows and choose "Connect to WSL..." → Ubuntu-22.04/home/matheus/projects/my-app.
  3. Claude Code installs its remote server in WSL (first time only) and opens the project. The status bar shows WSL: Ubuntu-22.04 — /home/matheus/projects/my-app — shell: zsh.
  4. I open the integrated terminal. It is a real zsh session inside WSL, with my .zshrc, my aliases, nvm loaded, and node -v returning the version I installed in Linux — not the Windows one.
  5. I ask Claude Code to "run the test suite and fix the failing tests." The agent runs pnpm test inside WSL, sees Linux paths in stack traces, edits files on the Linux filesystem, and re-runs the tests — all without ever touching PowerShell.
  6. I ask it to "spin up the dev environment." It runs docker compose up -d against the Linux Docker engine inside WSL. Volume mounts use native Linux paths and work correctly.
  7. I commit with git commit -S. GPG signing works because the agent is using the GPG agent configured in my WSL user profile.
  8. I close Claude Code, reopen it later, click the recent workspace entry, and I'm instantly back in the same WSL remote session.

Throughout this flow, I never had to deal with path translation, PowerShell quirks, broken symlinks, missing Linux tools, or slow file access over \\wsl.localhost\. The experience matches what I already get from VS Code Remote - WSL, but with Claude Code's agent capabilities fully integrated into the Linux environment.

Additional Context

Prior art and references

Why this matters for Claude Code specifically

Claude Code is agentic — it doesn't just edit files, it runs commands, inspects output, iterates on tests, and executes tooling. That makes the "which environment do commands actually run in?" question much more important than for a plain editor. If the agent runs npm test in PowerShell against a \\wsl.localhost\... path while the user's real toolchain, Docker, and CI all live in Linux, the agent's feedback loop becomes unreliable. Running the agent inside WSL fixes this at the root.

Environments to consider

  • WSL1 and WSL2 (WSL2 is the primary target; WSL1 can be best-effort).
  • Multiple installed distributions (Ubuntu, Debian, Arch, Kali, custom distros).
  • Non-default users and custom /etc/wsl.conf settings.
  • Shells other than bash (zsh, fish) and tools like direnv, asdf, mise.

Nice-to-haves (follow-ups, not required for the MVP)

  • Remote support beyond WSL (SSH, dev containers) using the same architecture.
  • Per-workspace remote configuration files checked into the repo.
  • Ability for the agent to surface "this command will run inside WSL as user X with shell Y" before executing, for transparency.

Summary

Please treat native WSL remote integration as a core platform feature for Claude Code Desktop on Windows. It would remove a major friction point for a large segment of professional developers and bring Claude Code to parity with other modern IDEs on this exact workflow.

View original on GitHub ↗

22 Comments

panfiva · 2 months ago

Just installed Claude desktop yesterday to learn it does not integrate with claude-code running in WSL. My use cases are as follows:

  1. I should be able to start Claude desktop inside WSL by running a command in shell and/or by running /desktop inside Claude code; A thin Windows client should launch using all preferences, skills and other configs from WLS.
  2. I should be able to easily find Claude project directory for each project created inside Claude Desktop. This will make it easier to edit project configurations (instructions and files) using VS Code and version control them.

There is a similar request (https://github.com/anthropics/claude-code/issues/12506), however it seems this request focuses on the key need that we have (native integration into WSL) instead of just running commands remotely in WSL.

+1 on this feature request

hdomos · 2 months ago

Also just installed Claude desktop and learnt it cannot be used easily with wsl. I have a linux stack that I use for development currently with VS code and its wsl integration but I would really like to switch to claude code.

I would like to use claude desktop as a mission control for running several worktree based sessions inside WSL in multiple projects at once.

p-clements · 2 months ago

This is absolutely required. Codex already offers this as well as VSCode as mentioned by the OP.

rclanan · 1 month ago

Can we please get this on the roadmap? I love that it has ssh support but native WSL support as well would be amazing!

JordanRL · 1 month ago

Considering that Claude Code is supposed to be a professional development environment, and that I sometimes get prompted to update my Claude Desktop multiple times in a single day, it's absolutely dumbfounding that this feature hasn't been included yet. Claude Desktop is basically just a toy until this feature lands.

gowanuslobster · 1 month ago

There is a cluster of issues that makes it seem like Anthropic / Claude generally speaking does not want to support Windows/WSL connectivity. This issue, the UNC path issue referenced above, the fact that Claude Code TUI in WSL doesn't support simple copy/paste of images, etc. Please Anthropic, this should be so easy! Just have Claude implement these features! In fact has to be a PR somewhere already that gets this right... Just have Claude find it for you & merge it!

bertPB · 1 month ago

$965B Company everyone...

RyanEwen · 1 month ago

I should have done more research when switching to Claude.. I was a bit shocked to find no WSL nor dev container support. All of our company's projects use dev containers...

shengyy · 1 month ago

Strong +1 on this. I'm a Windows + WSL2 developer — my entire Node.js/TypeScript stack (Next.js, Prisma, Docker) lives inside WSL2, and the current Desktop experience is painful: wrong shell, broken paths, toolchain mismatches. The SSH workaround is too clunky for daily use.
VS Code's Remote - WSL solved this years ago. Claude Code Desktop deserves the same. This would unlock the Desktop UI for a huge segment of Windows developers who rely on WSL2 as their primary dev environment.

QAnders · 1 month ago

Claude CLI works nicely in WSL2, but sometimes using Claude Desktop on Windows is preferable, especially when working with documentation in Office applications. Not having access to WSL2 file system with the code is very limiting so having file system access to Ubuntu in WSL2 would be great.

+1

Rothalack · 1 month ago

This should be getting more attention

brunoprietog · 1 month ago

My only option is to use Claude Code with VS Code, since the CLI is unusable for me due to accessibility issues. It would be great to be able to run Claude Code directly with WSL through the app without having to rely on VS Code.

QAnders · 1 month ago
CLI is unusable for me due to accessibility issues

Why is it not accessible? Security policy?

In a more "sane" interpretation running WSL2 CLI would be "safer" than running it in Windows as WSL is a virtual environment "locked in" under your Windows...

I combine VSCode and CLI... Having CLI adding a CLAUDE.md to the repository root directories seems to also have a great benefit to running it in VSCode as the Claude extension.

brunoprietog · 1 month ago

Nope, I mean accessibility with a screen reader, I'm blind.

QAnders · 1 month ago
Nope, I mean accessibility with a screen reader, I'm blind.

Oh, right! That makes sense! Sorry, didn't consider that option!
Respect!

abdullahkavakli · 11 days ago

Workaround: running Claude Desktop inside WSL with WSLg

I found a workaround that lets me run the Linux Claude Desktop app inside WSL2 using WSLg.

This is not the same as first-class "Remote - WSL" support in the native Windows app, but it does make Claude usable from the WSL/Linux side.

My environment:

WSL distro: Ubuntu 24.04.4 LTS
WSL version: WSL2
Architecture: amd64/x86_64
Claude package: claude-desktop 1.18286.0
GUI layer: WSLg

1. Install the Linux Claude Desktop package

I downloaded the official Linux .deb from Anthropic's apt repository and installed it inside WSL:

sudo apt install /home/<USER>/Downloads/claude-desktop/claude-desktop_1.18286.0_amd64.deb

After install:

command -v claude-desktop

returns:

/usr/bin/claude-desktop

2. Start GNOME Keyring before launching Claude

Without this, Claude warned:

Your sign-in won't be saved on this device. Install and unlock a
system keyring (such as GNOME Keyring), then restart the app.

The workaround is to start the Secret Service/keyring before launching Claude:

gnome-keyring-daemon --start --components=secrets

If the keyring is locked, unlock it:

gnome-keyring-daemon --unlock

3. Launch Claude with WSLg-friendly Electron flags

I also hit an invisible cursor issue inside the Claude window. Launching Claude with Wayland and disabling GPU acceleration fixed or improved that on my setup.

I created this wrapper:

mkdir -p ~/.local/bin
nano ~/.local/bin/claude-desktop-wsl

Wrapper contents:

#!/usr/bin/env bash
set -euo pipefail

gnome-keyring-daemon --start --components=secrets >/dev/null 2>&1 || true

export ELECTRON_OZONE_PLATFORM_HINT=wayland
export XCURSOR_THEME=Adwaita
export XCURSOR_SIZE=24

log_dir="${XDG_CACHE_HOME:-$HOME/.cache}"
mkdir -p "$log_dir"
log_file="$log_dir/claude-desktop-wsl.log"

cmd=(/usr/bin/claude-desktop --ozone-platform=wayland --enable-features=UseOzonePlatform --disable-gpu "$@")

if [[ -t 1 || -t 2 ]]; then
  setsid "${cmd[@]}" >>"$log_file" 2>&1 < /dev/null &
  printf 'Claude Desktop started. Logs: %s\n' "$log_file"
else
  exec "${cmd[@]}" >>"$log_file" 2>&1
fi

Then:

chmod +x ~/.local/bin/claude-desktop-wsl

Now I launch Claude with:

~/.local/bin/claude-desktop-wsl

4. Optional desktop launcher

I also created a user-local desktop launcher so the WSL app menu starts the wrapper instead of the raw binary:

mkdir -p ~/.local/share/applications
nano ~/.local/share/applications/claude-desktop.desktop

Contents:

[Desktop Entry]
Name=Claude
Comment=Desktop application for Claude.ai
GenericName=AI Assistant
Keywords=AI;Chat;Assistant;Claude;Code;LLM;
Exec=/home/<USER>/.local/bin/claude-desktop-wsl %U
Icon=claude-desktop
Type=Application
StartupNotify=true
StartupWMClass=claude-desktop
SingleMainWindow=true
Categories=Utility;Development;
MimeType=x-scheme-handler/claude;
Actions=NewChat;NewCode;

[Desktop Action NewChat]
Name=New chat
Exec=/home/<USER>/.local/bin/claude-desktop-wsl claude://claude.ai/new

[Desktop Action NewCode]
Name=New Claude Code session
Exec=/home/<USER>/.local/bin/claude-desktop-wsl claude://code/new

Notes

Some warnings still appear in logs under WSLg, for example:

drmGetDevices2() has not found any devices
Gtk: gtk_widget_get_scale_factor: assertion 'GTK_IS_WIDGET (widget)' failed
libnotify-WARNING **: Failed to connect to proxy
org.freedesktop.Notifications was not provided by any .service files

These seem to be WSLg/Electron/Linux-desktop-environment warnings rather than fatal errors. I redirect them to:

~/.cache/claude-desktop-wsl.log

Why this is only a workaround

This works well enough to launch the Linux GUI app from WSL, but it is still not ideal:

  • It requires running the entire GUI app through WSLg.
  • It needs manual keyring/session handling.
  • It may need Electron flags for cursor/rendering issues.
  • Notifications and desktop integrations are incomplete.
  • It creates a separate Linux app/config/update path from the native Windows app.

The better long-term solution would still be native Windows Claude Desktop/Claude Code UI with a real WSL backend, similar to VS Code Remote - WSL:

  • Windows UI stays native.
  • Commands run inside the selected WSL distro.
  • Linux $PATH, shell config, git config, SSH keys, package managers, and project paths are used directly.
  • Opening a WSL folder can attach the native desktop UI to that WSL environment.

It may help but WSL integration would be much cleaner.

rlmumford · 3 days ago

@codebytere-ant why has this been closed as completed? It isn't complete. Nothing has been done. A workaround has been posted, but even that workaround concludes:

The better long-term solution would still be native Windows Claude Desktop/Claude Code UI with a real WSL backend, similar to VS Code Remote - WSL: Windows UI stays native. Commands run inside the selected WSL distro. Linux $PATH, shell config, git config, SSH keys, package managers, and project paths are used directly. Opening a WSL folder can attach the native desktop UI to that WSL environment.

If you want to close as a won't do or not planned but don't claim it is completed.

p-clements · 3 days ago

Why is this closed?

abdullahkavakli · 3 days ago
## Workaround: running Claude Desktop inside WSL with WSLg I found a workaround that lets me run the Linux Claude Desktop app inside WSL2 using WSLg. This is not the same as first-class "Remote - WSL" support in the native Windows app, but it does make Claude usable from the WSL/Linux side. My environment: ``text WSL distro: Ubuntu 24.04.4 LTS WSL version: WSL2 Architecture: amd64/x86_64 Claude package: claude-desktop 1.18286.0 GUI layer: WSLg ` ### 1. Install the Linux Claude Desktop package I downloaded the official Linux .deb from Anthropic's apt repository and installed it inside WSL: `bash sudo apt install /home/<USER>/Downloads/claude-desktop/claude-desktop_1.18286.0_amd64.deb ` After install: `bash command -v claude-desktop ` returns: `text /usr/bin/claude-desktop ` ### 2. Start GNOME Keyring before launching Claude Without this, Claude warned: `text Your sign-in won't be saved on this device. Install and unlock a system keyring (such as GNOME Keyring), then restart the app. ` The workaround is to start the Secret Service/keyring before launching Claude: `bash gnome-keyring-daemon --start --components=secrets ` If the keyring is locked, unlock it: `bash gnome-keyring-daemon --unlock ` ### 3. Launch Claude with WSLg-friendly Electron flags I also hit an invisible cursor issue inside the Claude window. Launching Claude with Wayland and disabling GPU acceleration fixed or improved that on my setup. I created this wrapper: `bash mkdir -p ~/.local/bin nano ~/.local/bin/claude-desktop-wsl ` Wrapper contents: `bash #!/usr/bin/env bash set -euo pipefail gnome-keyring-daemon --start --components=secrets >/dev/null 2>&1 || true export ELECTRON_OZONE_PLATFORM_HINT=wayland export XCURSOR_THEME=Adwaita export XCURSOR_SIZE=24 log_dir="${XDG_CACHE_HOME:-$HOME/.cache}" mkdir -p "$log_dir" log_file="$log_dir/claude-desktop-wsl.log" cmd=(/usr/bin/claude-desktop --ozone-platform=wayland --enable-features=UseOzonePlatform --disable-gpu "$@") if [[ -t 1 || -t 2 ]]; then setsid "${cmd[@]}" >>"$log_file" 2>&1 < /dev/null & printf 'Claude Desktop started. Logs: %s\n' "$log_file" else exec "${cmd[@]}" >>"$log_file" 2>&1 fi ` Then: `bash chmod +x ~/.local/bin/claude-desktop-wsl ` Now I launch Claude with: `bash ~/.local/bin/claude-desktop-wsl ` ### 4. Optional desktop launcher I also created a user-local desktop launcher so the WSL app menu starts the wrapper instead of the raw binary: `bash mkdir -p ~/.local/share/applications nano ~/.local/share/applications/claude-desktop.desktop ` Contents: `ini [Desktop Entry] Name=Claude Comment=Desktop application for Claude.ai GenericName=AI Assistant Keywords=AI;Chat;Assistant;Claude;Code;LLM; Exec=/home/<USER>/.local/bin/claude-desktop-wsl %U Icon=claude-desktop Type=Application StartupNotify=true StartupWMClass=claude-desktop SingleMainWindow=true Categories=Utility;Development; MimeType=x-scheme-handler/claude; Actions=NewChat;NewCode; [Desktop Action NewChat] Name=New chat Exec=/home/<USER>/.local/bin/claude-desktop-wsl claude://claude.ai/new [Desktop Action NewCode] Name=New Claude Code session Exec=/home/<USER>/.local/bin/claude-desktop-wsl claude://code/new ` ### Notes Some warnings still appear in logs under WSLg, for example: `text drmGetDevices2() has not found any devices Gtk: gtk_widget_get_scale_factor: assertion 'GTK_IS_WIDGET (widget)' failed libnotify-WARNING **: Failed to connect to proxy org.freedesktop.Notifications was not provided by any .service files ` These seem to be WSLg/Electron/Linux-desktop-environment warnings rather than fatal errors. I redirect them to: `text ~/.cache/claude-desktop-wsl.log ` ### Why this is only a workaround This works well enough to launch the Linux GUI app from WSL, but it is still not ideal: - It requires running the entire GUI app through WSLg. - It needs manual keyring/session handling. - It may need Electron flags for cursor/rendering issues. - Notifications and desktop integrations are incomplete. - It creates a separate Linux app/config/update path from the native Windows app. The better long-term solution would still be native Windows Claude Desktop/Claude Code UI with a real WSL backend, similar to VS Code Remote - WSL: - Windows UI stays native. - Commands run inside the selected WSL distro. - Linux $PATH`, shell config, git config, SSH keys, package managers, and project paths are used directly. - Opening a WSL folder can attach the native desktop UI to that WSL environment. It may help but WSL integration would be much cleaner.

Update: It causes WSL crash dumps(~5GB). I wouldn't recommend unless you are desperate.

BrandonLWhite · 3 days ago

I am now seeing WSL as a directly supported environment as of a recent Claude Desktop update. I've been using it today instead of my previous SSH based solution, and so far so good.

<img width="385" height="428" alt="Image" src="https://github.com/user-attachments/assets/f9ccc516-cb10-436f-a5fc-2954d3fc2ed0" />

codebytere-ant · 2 days ago

hey folks just shipped this - throw feedback my way!

inayayousfi · 2 days ago
hey folks just shipped this - throw feedback my way!

Thanks for that feature, it feels so good using it. However, here is a few feedback I have to give so that I won't ever have to open my terminal again.

  • Having the terminal integration where it's just a sidebar, the same way we have for native windows, would be very cool.
  • When opening the file explorer to choose a path, in my opinion, it would be better to start at the home dir of the user rather than at the root of the file system.
  • And I don't know if it's related to this implementation, but being able to keep the permission option that we last used in this environment carry over to a new session would be great.