How to start Atom or VSCode natively installed on Windows from within WSL (Ubuntu)?

Question

I have installed Atom editor natively on Windows 10 by downloading an running the installer. Now I start WSL Ubuntu distro and want to start Atom (atom-editor) from there with the command atom . or VSCode (visual-studio-code) with the command code .

Atom starts, but not in the directory where the command was executed, instead it shows files from C:\\Windows. Moreover Ubuntu WSL terminal shows following error message:

atom .
grep: /etc/wsl.conf: No such file or directory
"\\wsl$\Ubuntu-18.04\home\wlad\projects\udemy\flask-bootcamp\Flask-Bootcamp-master"
CMD.EXE wurde mit dem oben angegebenen Pfad als aktuellem Verzeichnis gestartet.
UNC-Pfade werden nicht unterstützt.
Stattdessen wird das Windows-Verzeichnis als aktuelles Verzeichnis gesetzt.

Sorry it's German localized but it says something like UNC-paths are not supported

(haven't tested VSCode yet)

So how can I use Atom or VSCode editor installed on Windows 10 from within WSL?

** UPDATE ** As of today (April 2020) there is a much better way to use VSCode on Windows w/ WSL, VirtualMachines (VM) and even Containers. Check out remote-development plugin for VSCode.

Answer 1

I wrote a bash script to open atom with and without files from WSL2. It can handle any number (including 0) of file arguments, on any drive. Both relative and absolute paths are supported, but it can't handle path name containing .. or ~. Pointing atom to a director also works as expected. Here's my script:

#!/bin/bash
atom_cmd="/mnt/c/Users/`whoami`/AppData/Local/atom/atom.exe"
for i in "$@"; do
if [[ $i == /mnt* ]]; then 
    linPath="$i" #for absolute file paths
else 
    linPath="`pwd`/$i" #for relative file paths
fi
if [[ $linPath == *".."* || $linPath != "/mnt"* || $i == "/home"* ]] ; then
    echo "atom script is unacceptable file path $linPath"
    continue 1
fi
winPath="\""`echo $linPath | sed -e 's|\/mnt\/\([a-z]\)|\u\1:|' -e 's:\/:\\\\:g'`""
atom_cmd="$atom_cmd $winPath\""
done
unset linPath
unset winPath
echo "command:" "$atom_cmd"
eval "$atom_cmd"
unset atom_cmd

(I'm sure there are things to improve about this, like edge cases and better use of language features. I'd welcome suggestions.)

Answer 2

Wanting to run Atom from WSL got me here but unfortunately the accepted answer does not mention atom and the other atom related workarounds don't work anymore.

In case someone googles the question and ends up here. Here's an actual workaround (It will break in new Atom updates).

• Add the following path path in the windows enviroments: C:\Users\{username}\AppData\Local\atom\app-{version}\ (at the time of this post the version is 1.60.0 so app-1.60.0.

  • Use the path mentioned above as the default path contains a bash executable that will be run fail to run in wsl.
  • Here's where it will break in future updates. The fix is to update the env in windows to the new path since the folder where the exe is located will change to match atom's version.

• Add the following in your .bashrc or .zshrc:

  • Important to be added in .bashrc or .zshrc as making a separate script in /usr/bin will always make atom to open in the C:/Windows folder.

function _atom () { exec nohup atom.exe "$@" &> /dev/null & } # Do not output in terminal and do not block the terminal. Also send the command arguments to atom.

alias atom="_atom"

• Open a new wsl terminal.

Answer 3

this can be a little bit outdated but you can simply run a powershell and use:

wsl.exe -d Ubuntu-20.04 //In my case ubuntu

This should open a ubuntu session or whatever wsl you have set on your own.

A little bit nooby on this but trying to help. =)

Answer 4

The script in Eduardo's answer is a great approach, but didn't allow to open multiple directories/repos at once (e.g. atom terraform-modules terraform-repo), which I do often.

The following is my twist on it:

#!/bin/bash

winPathPrefix="U:"

function convertToWinPath() {
  echo "${winPathPrefix}$(realpath ${1})" | sed -e 's/\//\\/g'
}

declare -a atomCmd=(/mnt/c/Windows/System32/cmd.exe /c "atom")

for path in "$@"; do
  atomCmd+=($(convertToWinPath ${path}))
done

${atomCmd[@]} 2>/dev/null

That is entirely based on Eduardo's script and should allow a more general use case

Answer 5

I created a short script to handle the three atom commands I use most (I use Ubuntu with WSL):

1. atom
2. atom .
3. atom RELATIVE_PATH_FILE

This script is not optimized, and I'm sure many people will find edge cases, but it gets the job done for me. To use it, simply placed it in ~/.local/bin/atom and make it executable by running chmod +x ~/.local/bin/atom. You may need to restart your shell for ~/.local/bin to be added to your path. In order to simplify things a bit, I mapped the WSL network drive for my ubuntu installation to U:, so you'll either want to do the same or modify the script accordingly on line 9.

#!/bin/bash

if [ -z $1 ]; then
  pushd /mnt/c > /dev/null
  /mnt/c/Windows/System32/cmd.exe /c "atom"
else
  [[ $1 = "." ]] && path=$(pwd) || path=$(realpath $1)

  winPath=$(echo "U:$path" | sed -e 's/\//\\/g')

  pushd /mnt/c > /dev/null
  /mnt/c/Windows/System32/cmd.exe /c "atom $winPath"
fi

popd > /dev/null

The script performs a few simple steps. First, if there is no command line argument, it simply calls atom using cmd.exe without arguments. If the command line argument is ., it gets the path to the current directory, otherwise, it gets the absolute path to the given file using realpath. The path is converted from POSIX to Windows format using sed before calling atom using cmd.exe as before, but with the path argument.

The pushd and popd commands are just there to get rid of the annoying warning message about UNC paths not being supported:

...
CMD.EXE was started with the above path as the current directory.
UNC paths are not supported.  Defaulting to Windows directory

Answer 6

In the "Known issues" section of the blog post @Wlad mentioned, there states

Accessing Linux files is treated the same as accessing a network resource, and any rules for accessing network resources will still apply e.g: When using CMD, cd \\wsl$\Ubuntu\home will not work (as CMD does not support UNC paths as current directories), however copy \\wsl$\Ubuntu\home\somefile.txt C:\dev\ will work

So as Atom may use cmd.exe to launch itself from the command line (maybe some batch file), and given the fact that cmd.exe cannot open network resources as current directory (which WSL directory is treated as), there came the failure as you attempted to launch Atom from WSL shell.

Actually, in VS Code there is a better solution to launch VS Code directly from the WSL shell: VS Code Remote.

You can take the following steps to enable VS Code to be directly launched from WSL shell：

1. Install the extension Remote - WSL to VS Code on the Windows side;
2. Then when you type code . in your WSL shell, VS Code Remote Server will be automatically installed, and VS Code will soon launch.

By using VS Code Remote, you can not only open the directory in VS Code, but can also be benefited in many other aspects: for example, you can use the WSL shell as the integrated shell in VS Code and run programs in WSL directly from VS Code.

Here is the official doc for VS Code Remote - WSL.