The "developer edition" is a special version of the Mozilla Firefox web browser tailored for web developers. It has features stabilized in nightly builds, provides experimental developer tools, and it is configured for development, so some options as
remote debugging, are enabled by default.
The browser creates and uses a separate profile, so it can be used together with the standard edition of Firefox (on Linux, profiles are created inside the
In this tutorial we will see how to install Firefox Developer Edition on Linux, how to add the application to our PATH, and how to create a desktop launcher for it: the instructions can be applied to any Linux distribution.In this tutorial you will learn:
- How to download and install Firefox developer edition
- How to add the Firefox binary to PATH
- How to create a launcher for the application
Software Requirements and Conventions Used
|Category||Requirements, Conventions or Software Version Used|
|Other||Following this tutorial does not require any specific requirement|
|Conventions|| # - requires given linux commands to be executed with root privileges either directly as a root user or by use of |
Fetching the Firefox developer edition tarball
Firefox developer edition is distributed by Mozilla in a portable format and comes packaged in a tarball (all its dependencies are also contained in the tarball). We can download the tarball directly from the Firefox Browser Developer Edition Website.
The appropriate version and language for our system should be automatically detected when we click on the download button. In case we want to download an alternative version, all we have to do is to manipulate parameters of the download URL:
Say for example we want to download the
32bit version of the application: all we have to do is to change the value of the
os parameter from
linux. To change the application language, instead, we would pass the appropriate value to the
lang parameter: to download the Italian version, for example, we would use the following URL:
We can download the application also from the command line, using the
curl utility; if we combine it with
tar via a pipe, we can extract the tarball "on the fly". All we have to do is to run the following command:
$ curl --location "https://download.mozilla.org/?product=firefox-devedition-latest-ssl&os=linux64&lang=en-US" \ | tar --extract --verbose --preserve-permissions --bzip2
curl using the
--location option which is needed to make curl follow redirections, and providing the download URL. If not otherwise specified, curl writes its output to
stdout (standard output), so we use a pipe
| to redirect said output and use it as the standard input (
stdin) of the
We used the latter with some options:
--extract to perform an extraction,
--verbose (optional) to make the name of the extracted files be printed on the terminal when they are extracted,
--preserve-permissions to preserve the files permissions, and
--bzip2 to specify how the tarball should be decompressed. If everything go as planned, in the directory from which we executed the command, we will find a new "firefox" directory.
The next step consists into placing the Firefox directory somewhere more appropriate in our filesystem. In this tutorial we will install the application for our user only. By convention, self contained, global-installed applications are placed in the
/opt directory. There is not a standard per-user equivalent of this directory, so we will arbitrarily use
~/.local/opt as destination. The directory doesn't exist by default, therefore we must create it:
$ mkdir -p ~/.local/opt
We can then move the application directory:
$ mv firefox ~/.local/opt
Adding the Firefox binary to our PATH
At this point, the Firefox developer edition binary should be now
~/.local/opt/firefox/firefox. For convenience we want to add this binary to our
PATH. The value of the
PATH variable is a series of directory names separated by a
:, where applications are searched by default when they are invoked without specifying their absolute location. To check the content of the variable we can simply expand it:
$ echo $PATH /usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/home/egdoc/.local/bin
You can see that the
/home/egdoc/.local/bin directory is appended to my
PATH. This .local directory is created inside each user's home directory, and it's meant to contain per-user executables.
To add it to our
PATH, we can simply append the following line in our
.profile file, depending on the shell we are using (
.bash_profile is used by the bash shell, which uses
.profile has a fallback if it doesn't exists):
The file is sourced when we use an interactive login shell, so to make the changes effective we must logout and login again. At this point we must create a symbolic link to the Firefox developer edition binary inside the
~/.local/bin directory. We will name the link
firefox-dev in order to distinguish it form the standard Firefox binary:
$ ln -s ~/.local/opt/firefox/firefox ~/.local/bin/firefox-dev
We should now be able to launch the application from our terminal:
Creating a desktop launcher
Another thing we may want to do is to create a
.desktop launcher, in order to integrate the application in our desktop environment application launcher. The directory which hosts per-user desktop launchers is
~/.local/share/applications. Inside of it we must create the
firefox-dev.desktop file and place this content inside of it:
Name=Firefox Developer Edition GenericName=Web Browser Exec=/home/egdoc/.local/bin/firefox-dev %u Icon=/home/egdoc/.local/opt/firefox/browser/chrome/icons/default/default128.png Terminal=false Type=Application MimeType=text/html;text/xml;application/xhtml+xml;application/vnd.mozilla.xul+xml;text/mml;x-scheme-handler/http;x-scheme-handler/https; StartupNotify=true Categories=Network;WebBrowser; Keywords=web;browser;internet; Actions=new-window;new-private-window; StartupWMClass=Firefox Developer Edition [Desktop Action new-window] Name=Open a New Window Exec=/home/egdoc/.local/bin/firefox-dev %u [Desktop Action new-private-window] Name=Open a New Private Window Exec=/home/egdoc/.local/bin/firefox-dev --private-window %u
Let's briefly take a look at the file content. The
Name key is used to specify the application name and is mandatory. The
GenericName key, instead, is used to specify a generic name for the application and is optional.
Exec key is used to point to the program which should be invoked by the launcher, in this case
Icon key, is used to specify the launcher icon, while
Terminal is used to specify whether the program runs inside a terminal window or not. The
Type entry is used to specify the desktop entry type: it must be one among "Application", "Link" or "Directory".
To specify a list of the
MIME types supported by the applications we use the
MimeType key and separate the entries with a semicolon.
StartupNotify key is set to true, the cursor notifies the user when the application is started. When the application appears onscreen, the cursor returns to its original form (the application must support startup notifications).
Categories key is used to specify in which entries the application should be displayed in the menu, while
Keywords is used to specify a series of words separated by semicolon to be used as metadata for the application and facilitate its search.
Actions key is used to define separate actions other than the default one. Those actions can be chosen from the menu that appears when we right-click on the launcher and are then defined separately in their own sections, in this case
[Desktop Action new-window] and
[Desktop Action new-private-window]. The former is identical to the default one; the latter launches a private session by invoking the binary with the
StartupWMClass entry is used to define in which class the application is grouped the launcher menu. If we omit this key, we may find two entry of the desktop launcher: the one we clicked upon to launch the application, and the one which references the opened application.
In this tutorial we learned how to download and install Firefox developer edition, a version of Firefox tailored to web developers, which contains additional features not already ported to the standard version. We learned how to download and extract the tarball containing the application files, how to install it, how to add it to our PATH, and how to create a desktop launcher for the application.