IronFox

F-Droid QR Code:

---

IronFox is a fork of Divested Computing Group's Mull Browser, based on Mozilla Firefox. Our goal is to continue the legacy of Mull by providing a free and open source, privacy and security-oriented web browser for daily use.

Important

⚠️ All users are HIGHLY recommended to take a look at our documentation, ESPECIALLY the Limitations and Frequently Asked Questions pages!

While IronFox's home is GitLab, this repo is also mirrored to both Codeberg & GitHub.

Want to join the IronFox Community?

We'd love to see you over on Matrix (Recommended) and Discord!

App Installation

Currently, you can install IronFox from Accrescent, from your preferred F-Droid client via our F-Droid repository, with Obtainium, or directly from our GitLab releases.

Regardless of your installation method, we recommend verifying Ironfox's package ID and the checksum of its signing certificate. You can simplify this process using AppVerifier, which also has easy integration with Obtainium. See App Verification below for IronFox's Package ID & SHA-256 of the signing certificate.

If you are using F-Droid, we recommend F-Droid Basic as your client of choice. Due to its reduced feature set, F-Droid Basic has less attack surface; meaning it is more secure than the standard client.

It should be noted that our F-Droid repo is hosted using Cloudflare's R2 Storage (under the EU jurisdiction). While not perfect, Cloudflare does have a strong privacy track record, and due to their high reliabity and performance, we feel this is the best option for most users.

That being said, if you'd rather avoid Cloudflare, we also host a mirror of the F-Droid repo on Codeberg, though it comes at the cost of lower reliability & performance. You can add the following link to your F-Droid client:

https://codeberg.org/ironfox-oss/fdroid/raw/branch/main/fdroid/repo

Once added, within the repository's settings on F-Droid, you can disable the other mirrors & leave Codeberg as the only selected option.

We also mirror the F-Droid repo on GitLab here. You can add the following link to your F-Droid client if desired:

https://gitlab.com/ironfox-oss/fdroid/-/raw/main/fdroid/repo

App Verification

Package ID: org.ironfoxoss.ironfox

Package ID (Nightly): org.ironfoxoss.ironfox.nightly

SHA-256 Hash of Signing Certificate:

C5:E2:91:B5:A5:71:F9:C8:CD:9A:97:99:C2:C9:4E:02:EC:97:03:94:88:93:F2:CA:75:6D:67:B9:42:04:F9:04

Building

IronFox makes it easier (and faster) to build the project locally. For example, prebuilt versions of wasi-sdk sysroot and llvm-project are used instead of building them locally. F-Droid builds still build those from source.

It is recommended to use the Docker image for building IronFox.

Build with Docker

Pull the docker image with :

docker pull registry.gitlab.com/ironfox-oss/ironfox:latest

You can also use the main tag to pull the image which was used to build the latest IronFox release. Or you can use exact version names to pull images for those versions.

For example :

docker pull registry.gitlab.com/ironfox-oss/ironfox:v135-0

Then, you need to set up the source files.

Build without Docker

You need to install a few packages on your machine to be able to build IronFox. Follow the below instructions based on the OS you're using.

When building on Ubuntu

sudo apt update
sudo apt install -y make \
        cmake \
        clang-18 \
        gyp \
        nasm \
        ninja-build \
        patch \
        perl \
        tar \
        unzip \
        wget \
        xz-utils \
        yq \
        zlib1g-dev

Apart from the above packages, you need to install Python 3.9. You can use PPA from the deadsnakes team.

You will also need to install JDK 8 AND JDK 17, with JDK 17 set as the default JDK.

When building on Fedora 42

sudo dnf install -y \
    cmake \
    clang \
    gawk \
    git \
    gyp \
    m4 \
    make \
    nasm \
    ninja-build \
    patch \
    perl \
    python3.9 \
    shasum \
    wget \
    xz \
    yq \
    zlib-devel

You will also need to install JDK 8 AND JDK 17, with JDK 17 set as the default JDK. These can be installed from The Adoptium Working Group's repository.

To add The Adoptium Working Group's repository, you'll want to install Fedora's adoptium-temurin-java-repository package and enable the repository:

sudo dnf install -y adoptium-temurin-java-repository
sudo dnf config-manager setopt adoptium-temurin-java-repository.enabled=1
sudo dnf makecache

Now, to install JDK 8 and 17:

sudo dnf install -y temurin-8-jdk temurin-17-jdk

When building on macOS

NOTE: Homebrew is recommended for installation/management of dependencies on macOS.

/usr/bin/xcode-select --install
brew install \
    cmake \
    gawk \
    git \
    gsed \
    m4 \
    make \
    nasm \
    ninja \
    node \
    perl \
    python@3.9 \
    temurin@17 \
    wget \
    xz \
    yq \
    zlib

You should also ensure that python3.9 is available in your PATH:

export PATH="$PATH:$(brew --prefix)/opt/python@3.9/Frameworks/Python.framework/Versions/3.9/bin"

Once the packages have been installed successfully, follow the instructions to set up the build environment:

• Setup F-Droid's gradle script to be available in your PATH:

  mkdir -vp $HOME/bin
  wget --https-only --no-cache --secure-protocol=TLSv1_3 --show-progress --verbose https://gitlab.com/fdroid/gradlew-fdroid/-/raw/main/gradlew-fdroid -O "$HOME/bin/gradle"
  chmod +x "$HOME/bin/gradle"
  
  export PATH=$HOME/bin:$PATH
  

• Disable Gradle Daemons and configuration cache:

  mkdir -vp ~/.gradle
  echo "org.gradle.daemon=false" >> ~/.gradle/gradle.properties
  echo "org.gradle.configuration-cache=false" >> ~/.gradle/gradle.properties
  

• Create a new Python 3.9 virtual environment, then activate it:

  python3.9 -m venv env
  source env/bin/activate
  

  • On macOS, after creating your Python 3.9 virtual environment, you will also need to install gyp-next:

    pip install gyp-next
    

• Ensure JDK 17 is the default JDK. You can check the current JDK version by running java --version in the terminal. Otherwise, you can temporarily set JDK 17 as the default by running:

  Don't forget to replace /path/to/jdk-17 below with the actual path of your JDK 17 installation!

  export JAVA_HOME=/path/to/jdk-17
  export PATH=$JAVA_HOME/bin:$PATH
  

  For instance, on Fedora 42, the default location of JDK 17 is /usr/lib/jvm/temurin-17-jdk:

  export JAVA_HOME=/usr/lib/jvm/temurin-17-jdk
  export PATH=$JAVA_HOME/bin:$PATH
  

  On macOS, the default location of JDK 17 is /Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home:

  export JAVA_HOME=/Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home
  export PATH=$JAVA_HOME/bin:$PATH
  

• Ensure that the ANDROID_HOME variable points to a valid Android SDK installation (default location is $HOME/android-sdk). Otherwise, you can execute the following to install and set up the SDK:

  source scripts/setup-android-sdk.sh
  

  • NOTE: On macOS, you MUST ensure that the ANDROID_HOME variable is defined before running setup-android-sdk.sh. For example, if I want to use the default location ($HOME/android-sdk) for my Android SDK, I would use:

    export ANDROID_HOME=/Users/user/android-sdk
    

Get & patch sources

Next, you need to download the source files to build. The scripts/get_sources.sh file can be used to download/clone the source files.

This may take some time depending on your network speed...

./scripts/get_sources.sh

If you need to fetch sources for a different version of Firefox than the one IronFox is currently based on, you'll have to modify the script directly.

Once the source files are downloaded and extracted, you need to source the scripts/env_local.sh script (generated by get_sources.sh) to set up the required environment variables:

source scripts/env_local.sh

Next, you need to patch the files with:

This must be run once after getting your sources.

./scripts/prebuild.sh <build-variant>

Where <build-variant> specifies the variant to build, and is one of the following:

• arm - 32-bit ARM (armeabi-v7a)
• arm64 - 64-bit ARM (arm64-v8a)
• x86_64 - 64-bit x86
• bundle - Android App Bundle (AAB) with all supported ABIs.

Important

If you want to build the bundle variant locally, you need to build the ABI-specific variants first, get the generated AAR file for GeckoView and then configure MOZ_ANDROID_FAT_AAR* environment variables with the path to the generate AAR files.

See task kinds and ci-build.sh for more details.

Build

Finally, you can start the build process with:

./scripts/build.sh apk

Translation

IronFox is translated using Weblate. Visit the Weblate project to help with translations.

Licensing

The scripts are licensed under the GNU Affero General Public License, version 3 or later.

Changes to patches are licensed according to the header in the files this patch adds or modifies (Apache 2.0 or MPL 2.0).

Phoenix is licensed under the GNU General Public License v3.0 or later (GPL-3.0-or-later) where applicable. See COPYING.

a-c-liberate.patch, a-c-localize-maven.patch, a-s-localize-maven.patch, fenix-liberate.patch, gecko-localize-maven.patch, and microg-unbreak-fido.patch are adapted from Fennec F-Droid. See COPYING.

gecko-rs-blocker.patch and gecko-custom-ublock-origin-assets.patch, are adapted from LibreWolf. See LibreWolf License and Disclaimers.

fenix-disable-network-connectivity-monitoring.patch, gecko-disable-network-id.patch, geckoview-ironfox-settings-support-spoof-english.patch, and glean-noop.patch are adapted from the Tor Project. See LICENSE.

Our current set of default wallpapers are taken from Fennec F-Droid, and are available under the Unsplash license.

Notices

Mozilla Firefox is a trademark of The Mozilla Foundation.

This is not an officially supported Mozilla product. IronFox is in no way affiliated with Mozilla.

IronFox is not sponsored or endorsed by Mozilla.

IronFox is not associated with DivestOS, Divested Computing Group, or Mull in any manner.

Firefox source code is available at https://github.com/mozilla-firefox/firefox.