gtk-launch

With any recent Ubuntu that supports gtk-launch just simply go

gtk-launch <file>

Where <file> is the name of the .desktop file with or without the .desktop part. The name must not include the full path.

The .desktop file must be in /usr/share/applications, /usr/local/share/applications or ~/.local/share/applications.

So gtk-launch foo opens /usr/share/applications/foo.desktop (or foo.desktop located in one of the other permitted directories.)

From gtk-launch documentation:

gtk-launch launches an application using the given name. The application is started with proper startup notification on a default display, unless specified otherwise.

gtk-launch takes at least one argument, the name of the application to launch. The name should match application desktop file name, as residing in /usr/share/application, with or without the '.desktop' suffix.

Usable from terminal or Alt + F2 (Alt + F2 stores command in history so it's easily accessible).

The answer should be

xdg-open program_name.desktop

But due to a bug (here upstream, closed on 2020-12-09) this no longer works.

Modern Answer

gtk-launch <app-name> - where <app-name> is the file name of the .desktop file, with or without the .desktop extension.

See another answer on this thread for more details. I got this info from that answer.

Deprecated shell tools answer

Written a long time ago - see the comments below this answer as to why this approach won't work for many desktop files.

The command that is run is contained inside the desktop file, preceded by Exec= so you could extract and run that by:

$(grep '^Exec' filename.desktop | tail -1 | sed 's/^Exec=//' | sed 's/%.//' \
| sed 's/^"//g' | sed 's/" *$//g') &

To break that down

grep  '^Exec' filename.desktop    # - finds the line which starts with Exec
| tail -1                         # - only use the last line, in case there are 
                                  #   multiple
| sed 's/^Exec=//'                # - removes the Exec from the start of the line
| sed 's/%.//'                    # - removes any arguments - %u, %f etc
| sed 's/^"//g' | sed 's/" *$//g' # - removes " around command (if present)
$(...)                            # - means run the result of the command run 
                                  #   here
&                                 # - at the end means run it in the background

You could put this in a file, say ~/bin/deskopen with the contents

#!/bin/sh
$(grep '^Exec' $1 | tail -1 | sed 's/^Exec=//' | sed 's/%.//' \
| sed 's/^"//g' | sed 's/" *$//g') &

Then make it executable

chmod +x ~/bin/deskopen

And then you could do, e.g.

deskopen /usr/share/applications/ubuntu-about.desktop

The arguments (%u, %F etc) are detailed here. None of them are relevant for launching at the command line.

While OP was not asking about KDE, for anyone that is running KDE the following command can be used:

kioclient exec <path-to-desktop-file>

On Fedora, this is included in the kde-runtime rpm. On Arch, it is in kde-cli-tools (HT: @Aron Cederholm).

Since glib 2.67.2 there's a gio launch command that can be used like this:

gio launch ./foo.desktop

For older releases I've got a quick workaround (stealing inspiration from the nautilus source code). It is a bit convoluted, but works flawlessly on Ubuntu 12.10, adding a meaningful icon (no more ?) on the Unity launcher.

First, I wrote a python script using Gio and placed saved it as ~/bin/run-desktop :

#!/usr/bin/python

from gi.repository import Gio
import sys 

def main(myname, desktop, *uris):
    launcher = Gio.DesktopAppInfo.new_from_filename(desktop)
    launcher.launch_uris(uris, None)

if __name__ == "__main__":
    main(*sys.argv)

The script needs to have the executable permission, so I ran this in a terminal:

chmod +x ~/bin/run-desktop

Then I created the relative .desktop entry on ~/.local/share/applications/run-desktop.desktop:

[Desktop Entry]
Version=1.0
Name=run-desktop
Exec=run-desktop %U
MimeType=application/x-desktop
Terminal=false
Type=Application

Finally, I associated the entry as the default handler in ~/.local/share/applications/mimeapps.list under the [Default Applications] section as :

[Default Applications]
....
application/x-desktop=run-desktop.desktop

Now:

• xdg-open something.desktop works as expected
• #!/usr/bin/xdg-open hashbang on top of an executable desktop entry works too

The Right Way

You should really be using gtk-launch if it is available. It is usually part of the package libgtk-3-bin (this may vary by distro).

gtk-launch is used as follows:

gtk-launch APPLICATION [URI...]
gtk-launch app-name.desktop
gtk-launch app-name

Please note that gtk-launch requires the .desktop file to be installed (i.e. located in /usr/share/applications or ~/.local/share/applications).

So to get around this, we can use a hackish little Bash function that temporarily installs the desired .desktop file before launching it. The "correct" way to install a .desktop file is via desktop-file-install but I'm going to ignore that.

launch(){

    # Usage: launch PATH [URI...]

    # NOTE: The bulk of this function is executed in a subshell, i.e. `(..)`
    #       This isn't strictly necessary, but it keeps everything
    #       out of the global namespace and lessens the likelihood
    #       of side effects.

    (

    # where you want to install the launcher to
    appdir=$HOME/.local/share/applications

    # the template used to install the launcher
    template=launcher-XXXXXX.desktop

    # ensure $1 has a .desktop extension, exists, is a normal file, is readable, has nonzero size
    # optionally use desktop-file-validate for stricter checking
    # desktop-file-validate "$1" 2>/dev/null || {
    [[ $1 = *.desktop && -f $1 && -r $1 && -s $1 ]] || {
        echo "ERROR: you have not supplied valid .desktop file" >&2
        return 1
    }

    # ensure the temporary launcher is deleted upon exit
    trap 'rm "$launcherfile" &>/dev/null' EXIT

    # create a temp file to overwrite later
    launcherfile=$(mktemp -p "$appdir" "$template")

    launchername=${launcherfile##*/}

    # overwrite temp file with the launcher file
    if cp "$1" "$launcherfile" &>/dev/null; then
        gtk-launch "$launchername" "${@:2}"
    else
        echo "ERROR: failed to copy launcher to applications directory" >&2
        return 1
    fi

    )

}

You can use it like so (and also pass along additional arguments or URIs if you want):

launch PATH [URI...]
launch ./path/to/shortcut.desktop

The Manual Alternative

If you want to manually parse and execute a .desktop file, you can do so with the following awk command:

awk '/^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); exit system($0)}' app-name.desktop

If you want to treat the awk command like an all-in-one script; we can even show an error message and exit with a return code of 1 in the event that an Exec command is not found:

awk 'BEGIN {command=""} /^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); command=$0; exit} END {if (command!="") {exit system(command)} else {if (FILENAME == "-") {printf "ERROR: Failed to identify Exec line\n" > "/dev/stderr"} else {printf "ERROR: Failed to identify Exec line in \047%s\047\n", FILENAME > "/dev/stderr"} close("/dev/stderr"); exit 1}}'

The aforementioned commands will:

1. Find the line starting with Exec=
2. Remove Exec=
3. Remove any Exec variables (e.g. %f, %u, %U). It is possible to replace these with positional arguments as the specification intends, but doing so would add significant complexity to the problem. See latest Desktop Entry Specification.
4. Execute the command
5. Immediately exit with the appropriate exit code (so as to not execute multiple Exec lines)

Note, this AWK script addresses a few edge cases that may or may not be properly addressed by some of the other answers. Specifically, this command removes multiple Exec variables (taking care not to otherwise remove the % symbol), will only execute a single Exec line command, and will behave as expected even if the Exec line command contains one or more equals sign (e.g. script.py --profile=name).

Just a few other caveats... According to the specification, TryExec is:

Path to an executable file on disk used to determine if the program is actually installed. If the path is not an absolute path, the file is looked up in the $PATH environment variable. If the file is not present or if it is not executable, the entry may be ignored (not be used in menus, for example).

With that in mind, it doesn't make sense to execute it's value.

Some other concerns are Path and Terminal. Path consists of the working directory to run the program in. Terminal is a boolean that indicates whether the program is run in a terminal window. These can all be addressed, but there's no sense in reinventing the wheel as there are already implementations of the spec. If you do want to implement Path, keep in mind that system() spawns a subprocess, so you can't change working directory by doing something like system("cd \047" working_directory "\047"); system(command). However you could presumably do something like system("cd \047" working_directory "\047 && " command). Note \047 are single quotes (so the command doesn't break on paths with spaces).

The Python Alternative

I'm stealing a page from Carlo here, who suggested creating a Python script to make use of the gi module. Here's a minimal way to execute the same code from the shell without having to create a file and worry about I/O.

launch(){

# Usage: launch PATH [URI...]

python - "$@" <<EOF
import sys
from gi.repository import Gio
Gio.DesktopAppInfo.new_from_filename(sys.argv[1]).launch_uris(sys.argv[2:])
EOF

}

Then execute the launcher function as follows:

launch ./path/to/shortcut.desktop

Note the use of URIs is optional. Also, no error checking is performed so you'll want to ensure the launcher exists and is readable (before using it) if you want your script to be durable.

You could use dex.

Install dex:

sudo apt install dex

Run the file with it:

dex foo.desktop

exo-open [[path-to-a-desktop-file]...]

seems to work in 13.10 release, if exo-utils is installed (like is the case with Xubuntu).

(Compiled from the various other answers here)

Depending on your system, and the various bugs that may or may not exist on your system, try the following until one of them works:

1. xdg-open program_name.desktop
2. exo-open program_name.desktop [my preferred choice, whenever it works]
3. gtk-launch program_name.desktop
4. kioclient exec program_name.desktop
5. dex program_name.desktop
6. Or, here's a command from @Hamish Downer which grep-searches the *.desktop file for the Exec= line containing the command to execute, removes parts of that line we don't want, then executes it. It is well-written and works well for most desktop files. See his answer for a full explanation of it.

   # To execute the `Exec=` cmd from filename.desktop in the background
   $(grep '^Exec' filename.desktop | tail -1 | sed 's/^Exec=//' \
   | sed 's/%.//' | sed 's/^"//g' | sed 's/" *$//g') &
   
   # Or, remove the `&` at the end to execute it in the foreground so you 
   # can see output from running the command too
   $(grep '^Exec' filename.desktop | tail -1 | sed 's/^Exec=//' \
   | sed 's/%.//' | sed 's/^"//g' | sed 's/" *$//g')
   

Note that on Ubuntu systems, your "start menu" desktop launchers are available in /usr/share/applications/.

As an example, to show which of the above commands do or don't work on my Ubuntu 14.04 system, here are the results of the following calls for me:

1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Fails due to bug (tries to have me save this .desktop file)
2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Works
3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Fails with "gtk-launch: no such application"
4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Works
5. dex /usr/share/applications/eclipse_for_cpp.desktop # Fails, & sudo apt install dex cannot locate package dex
6. $(grep '^Exec' /usr/share/applications/eclipse_for_cpp.desktop | tail -1 | sed 's/^Exec=//' | sed 's/%.//' | sed 's/^"//g' | sed 's/" *$//g') & # Works

Addendum to Hamish's answer.

Given the deskopen script, you can use a reference to it as the shebang line in a .desktop file, since the comment character is still #. That is to say, put this as the first line of the .desktop file:

#!/usr/bin/env deskopen

Then flag the .desktop file as executable (e.g. with a chmod +x whatever.desktop), and then you can

path/to/whatever.desktop

and voilà -- The app will open! (Complete with the icon file I specified, though I have no idea how.)

Now, if you also want deskopen to pass through any command-line parameters, you can instead use this slightly-modified version:

#!/bin/sh
desktop_file=$1
shift
`grep '^Exec' "${desktop_file}" | sed 's/^Exec=//' | sed 's/%.//'` "$@" &

As an aside, I tried using "#{@:2}" instead of shifting, but it kept giving me 'bad substitution'...