Sailfish OS on Sony Xperia: Installation, Support, and Advanced Guide

If you're considering switching from Android to Sailfish OS on your Sony Xperia, you'll find what you need here. A complete guide in Spanish, designed for Spain, with everything you need to know before you jump in: compatible phones, real limitations, installation steps and even how to compile your own images for the latest models.

The goal is for you to be able to install Sailfish OS on an Xperia X, Xperia 10, 10 IV, or 10 V without any unpleasant surprises, understanding what will and won't work, how to prepare your PC and phone, and what to do if something goes wrong. You'll see both the "quick" method of flash official or prepared images such as the advanced approach to community ports using Jolla's HADK.

Compatible Sony Xperia models and Sailfish OS maturity

The Xperia family is, as of today, The most recommended option if you want to use Sailfish OSbecause Jolla, as the article on the return of the European Linux mobile, has worked hand in hand with Sony within the Open Devices program and, in addition, the community has created very polished adaptations for several models.

In this guide we're going to focus on the Xperia X, Xperia 10, Xperia 10 IV and Xperia 10 VThese are the ones that have official or almost official instructions, ready-to-flash images, and a documented support status from Jolla.

In the case of Sony Xperia 10VThere is already official support in the form of a trial version included in Sailfish OS 5.0.0.71: it's functional for day-to-day use, but still has some issues. major flaws such as the camera being disabled due to problems with Sony drivers and a bug that The battery percentage may freeze during use.

Something similar happens with the Xperia 10IVAccording to Jolla's adaptation status, overall connectivity is fairly well covered, since The modem, mobile data, GPS, Bluetooth, WiFi, tethering, sensors, and multimedia components are all working.But two key pieces are still missing: the camera is not working and neither is the fingerprint reader.

If we look at slightly older models, such as Xperia 10 (Android 9 base, ganges family) y Xperia X (Android 6/7 on Loire platform)The film changes completely: here the support is very mature, with Telephony, data, camera, sensors, and OTA updates are all working quite stably.Although there are still some minor details to refine, such as the behavior of the compass, some specific gestures, or battery consumption that could be improved in certain builds.

In any case, Jolla maintains a section of Adaptation Status This list, for each supported Xperia model, shows which components work well and which still fail. It's advisable to review it before flashing, especially on recent devices like Xperia 10 IV and 10 V where the camera and the footprint are still in the air.

General prerequisites: bootloader, PC and tools

Before touching anything on your mobile phone, it is essential to make sure that Your Xperia allows you to unlock the bootloader and that your computer is ready with Fastboot, ADB and, if you are going to compile, with the necessary development environment.

Check if the bootloader can be unlocked

On both newer and older Xperia models, the process is similar: open the phone app and dial the service code. * # * # * # * # 7378423You will see the Sony internal menu where you will have to enter. Service info> Configuration> Rooting Status.

If that screen appears “Bootloader unlock allowed: Yes”You're in luck: the device accepts the unlock and you'll be able to install Sailfish OS. If it says "No" or that line doesn't even appear, You won't be able to unlock the bootloader, and forget about Sailfish OS on that device..

For models covered by Sailfish X (Xperia X, Xperia 10 and others in the compatible range), Sony also offers the section Open Devices On their developer website, you can check compatibility, obtain the unlock code using the IMEI, and confirm if your specific variant is included in the program.

Preparing the computer: Fastboot, ADB and build environment

To flash Sailfish, you usually use a PC with GNU/Linux, where you will need at least Fastboot and ADB correctly installedOn Debian or Ubuntu-based systems, the standard packages are sufficient:

sudo apt-get install android-tools-fastboot android-tools-adb

In Fedora and other RPM-based distributions, the following packages are commonly used:

sudo dnf install android-tools

If your idea goes beyond flashing an official image and you want compile your own Sailfish OS builds for Xperia 10, 10 IV or 10 VYou will need to set up a complete AOSP build environment following Google's recommendations regarding memory, CPU, file system, and so on, and also install the Sailfish OS Platform SDK and HADK.

In recent ports based on Android 11 and 13, it is recommended to reserve between 200 and 300 GB of disk space for source code and compilation products, and have at least 50 GB of download space available, plus a decent broadband connection.

Disable USB auto-suspend in Linux to avoid errors

A recurring problem when flashing from some modern Linux distributions with ports USB 3.0 The kernel can "put the device to sleep" mid-process, causing errors such as “Requested download size is more than max allowed” or sudden disconnections while Fastboot is writing critical partitions.

To be on the safe side, it's a good idea to disable USB auto-sleep before starting important flashing by running:

echo -1 | sudo tee /sys/module/usbcore/parameters/autosuspend

This simple adjustment prevents the system from entering selective suspension of the USB device during flashing, which could leave the phone in an intermediate state and force you to repeat the entire operation from Android.

Preparing the Xperia: Developer mode and Fastboot

With mobile compatibility confirmed and the tools ready on the PC, the next step is prepare your own Xperia Enabling developer options, OEM unlocking, and USB debugging, as well as learning how to enter Fastboot and Fastbootd.

Enable developer options, USB debugging, and OEM unlocking

On all Xperia devices the flow is similar: open Settings> Phone information and tap repeatedly on the build number until Android tells you that you are now a developer. Then go back and enter Developer Options (sometimes within “System > Developer options”).

Within that menu, you must enable at least two key switches: OEM unlock y USB debuggingIt is important that the mobile phone has an internet connection while you activate the OEM unlock because Android checks with Google/Sony servers if that action is allowed for your device.

Enter Fastboot and Fastbootd mode

To unlock the bootloader and flash Sailfish OS, you'll need to be comfortable using Fastboot mode (and Fastbootd on modern A/B models). The classic method involves:

• Turn the phone off completely.
• Connect the USB cable to the computer, leaving the mobile phone end still disconnected.
• Press and hold the key turn up the volume while you plug the cable into the Xperia.

If you've done it correctly, the notification LED on your phone will light up. color azulThis indicates that it's in Fastboot mode. You can also reboot from Android with:

adb reboot bootloader

On recent Xperia devices, Jolla's own official scripts can automatically reboot from classic Fastboot to Fastbootd, an extended mode used to flash logical partitions under the modern Android scheme.

Unlocking the bootloader on a Sony Xperia

Unlocking the bootloader is a critical step: It completely erases all data from the phone and it may affect your Sony warranty. Before doing so, it's a good idea to use Android for a while and Verify that calls, camera, mobile data, sound, and microphone are working.Because if something comes defective from the factory, it will be easier to process the warranty with the original system.

Get the unlock code from the Sony website

For models in the Open Devices program (such as Xperia X and Xperia 10 (in its various versions), you'll need to go to the Sony developer page, enter the unlocking section, and select your specific model. There you will request the IMEI of the device and an email address.

Once you submit the form, the website itself will show you (and/or send you by email) a unique unlock codewhich you will later use with Fastboot. Remember that when running the command you will have to add the prefix 0x in front of the code and usually invoke Fastboot with the Sony USB identifier.

Execute the unlock command using Fastboot

With the phone in Fastboot mode (blue LED) and a terminal open in the working directory where you have the tools, the typical command to unlock an Xperia X or similar from Linux is:

sudo fastboot -i 0x0fce oem unlock 0xTU_CODIGO_DE_DESBLOQUEO

If everything goes well, you'll see a response like this: “OKAY” With the execution time, the phone will have an unlocked bootloader. From that moment on, the device will be ready for Flashing Sailfish OS images or any other compatible AOSP ROM, always bearing in mind that the data erasure is total.

Install an official or pre-made Sailfish OS image

For most users, that's more than enough. flash an official Sailfish X image or a ZIP file prepared by Jollawithout going into code factories. This is the recommended method for Xperia X, Xperia 10, and also for Xperia 10 IV/V when Jolla releases the corresponding packages.

Download and extract the Sailfish OS ZIP file.

The first thing is to buy the license at the Jolla Shop With your account, you will gain access to the downloads section. From there, you can download the Sailfish OS image that corresponds to your model, generating a ZIP file whose name includes the version number, the device identifier, and an internal suffix, for example:

• Sailfish_OS-Jolla-4.5.0.18-f5121-1.0.0.9.zip for the Xperia X F5121.
• Sailfish_OS-Jolla-4.5.0.18-f5122-1.0.0.9.zip for the Xperia X F5122.

Once you have downloaded the file, copy it to a working directory and unzip itYou will find the flashing scripts (like flash.sh), the image fragments (sailfish.img001etc.), integrity files (for example md5.lst) and, in some cases, specific tools for Windows, Linux and Mac.

Integrate Sony's proprietary binaries (vendor blobs)

In addition to the Sailfish package, you need the AOSP binaries that Sony publishes for each device familySailfish relies on them for closed drivers and components. These come in ZIP files containing a .img file, and their name indicates the Android base and platform codename.

For example, for Xperia X A ZIP file of the type is used SW_binaries_for_Xperia_AOSP_M_MR1_3.10_v13_loire.zipwhile for recent generations based on Android 11 or 13 you can find names like SW_binaries_for_Xperia_Android_11_4.19_v9a_lena.img o SW_binaries_for_Xperia_Android_14_5.4_v3a_murray.img y …_zambezi.img according to the hardware family.

The procedure is similar in all cases: you download the ZIP file from the Sony developer website, unzip it, and Copy the resulting .img file to the same folder where the unzipped Sailfish image is located.It is crucial that the filename matches what the flashing script expects; otherwise, flash.sh will complain that it cannot find the file.

If you need to use a different binary version than expected, you will have to edit the script flash.sh or flash-config.sh such as the checksum file (for example md5.lst) to adjust the name and hash of the new .img. If these details are not touched, the process will abort upon detecting an integrity discrepancy.

Flashing with flash.sh in Linux

With the bootloader unlocked, the Sailfish OS image unzipped, and the Sony .img in the same directory, standard flashing from GNU/Linux is reduced to opening a terminal in that folder and running:

sudo bash ./flash.sh

The script will guide you through the console, prompting you to put the Xperia into Fastboot mode when needed and automatically restarting it in between. Fastboot and Fastbootd to record all the necessary partitions (system, vendor, userdata, dtbo, boot_a/boot_b, etc.).

During this process You must not unplug the cable or touch the phone.It is recommended not to use the PC for anything critical until you see a message such as "Flashing completed. Remove the USB cable and boot up the device by pressing the power key" or similar.

If you encounter errors like “Requested download size is more than max allowed”On some systems, forcing a smaller block size with Fastboot using the option can help. -S, for example -S 512KThis requires editing the flash.sh script or manually repeating the problematic commands with that flag.

First boot of Sailfish OS and license activation

Once the script confirms it has finished and you disconnect the cable, simply hold down the power button to boot the Xperia. First, you will see a message. bootloader unlocked, then the Sony logo and, finally, the Sailfish OS boot animation.

On the first startup, the following is executed: Welcome assistant (Startup Wizard)where you will need to choose the language, accept the terms of use, define the device lock code, set the date and time, connect to a network and Log in with your Jolla account.

That login is what activates the licensed components: Android AppSupport, predictive text in Spanish, Microsoft Exchange compatibility and full access to the Jolla Store. During this setup, you can also install Aptoide as your Android app store, although many users prefer alternatives such as F-Droid, Aurora Store or UpToDown downloaded and installed separately.

Compile your own Sailfish OS image (HADK and community ports)

If you're up for a challenge and prefer to create custom images, Jolla offers the HADK (Hardware Adaptation Development Kit), a fairly extensive manual that explains how to set up an AOSP environment and generate a Sailfish OS image for different devices in the Sony Open Devices program.

Download the HADK and host requirements

The first step is to get the latest version of the HADK document and carefully read the initial disclaimer and chapters 1 and 2, where the workflow, the use of the Platform SDK and the basic concepts are explained: droid-hal, droid-config, droid-system, etc.

Although the document itself sets minimum requirements, in practice for modern devices (especially those based on Android 13 such as Xperia 10 IV and 10 VIt is recommended to have plenty of resources, with up to 300 GB of disk space And good RAM, since AOSP source synchronization and kernel and framework builds are quite heavy.

You will also need to install the Sailfish OS Platform SDK and define environment variables in ~/.hadk.env to indicate manufacturer, device, hardware family and base version of Android on which the adaptation is built.

Environment variables for Xperia 10 IV and 10 V (AOSP 13)

In the Xperia 10 IV and 10 V, the base is AOSP 13 and specific branches of mer-hybris are used. An example environment configuration for Xperia 10 IV (commercial model XQ-CC54, internal identifier pdx225, Murray family) could be:

export VENDOR=sony
export DEVICE=xqcc54
export HABUILD_DEVICE=pdx225
export FAMILY=murray
export ANDROID_VERSION_MAJOR=13
export HAVERSION="sony-aosp-"$ANDROID_VERSION_MAJOR

On Xperia 10V The pattern is similar, changing DEVICE and HABUILD_DEVICE to the correct values ​​for the family Zambezi (for example, pdx235). From here, HADK advises following the Chapters 3 and 4 to configure the AOSP environment and skip to chapter 5, replacing it with the sequence of specific scripts that clone the correct repositories and apply the mer-hybris patches.

Synchronize AOSP, apply patches, and compile hybris-hal

With the environment ready, you'll need to make sure you have the command repo installed to manage AOSP manifests. The simplified flow includes steps such as:

• Clone the repository droid-hal-sony- with all its submodules recursively.
• Initialize repo pointing to the mer-hybris manifest for the branch $HAVERSION and synchronize everything with repo sync.
• Clone droid-src-sony and apply your own patches using scripts like droid-src/apply-patches.sh --mb.
• Run ./setup-sources.sh --mb to prepare the compilation source tree.
• Load build/envsetup.sh, Activate ccache and select the target with lunch aosp_$DEVICE-user.

On modern Sony platforms with a common kernel 5.4 It is usually necessary to compile the kernel using scripts like build-kernels-clang.sh and make sure the image dtbo The resulting file is copied to the appropriate product folder. Then it is cloned. droidmedia and are compiled hybris-hal y droidmedia with a make -j$(nproc --all)which may take quite a while depending on the machine.

Generate droid-hal packages, middleware, and syspart

Once the boot images (hybris-boot, recovery) and base modules are ready, you move on to the Platform SDK and follow the Chapter 6 of the HADK, which explains how to integrate droid-hal and generate RPMs using the script rpm/dhd/helpers/build_packages.sh with different flags like –droid-hal, –gg (graphics) or –mw (middleware).

In parallel, the packages are being built droid-system and, in some cases, droid-vendor, assembling the images system.img y vendor.img generated by AOSP in temporary directories and using copy scripts (for example copy_tree.sh, copy_vendor.sh) that fill the RPM templates (droid-system-sony-template, droid-vendor-sony-template).

It's relatively normal to find minor patch conflicts in files like init.wod.rc o ld.config.28/29.txtwhich HADK itself indicates can be ignored or trivially resolved, as they affect fine-tuning. The important thing is to eliminate the key RPMs: droid-hal, droid-hal-img-boot, droid-hal-version, droid-system and company.

Create the flashable image with MIC

Once the hardware and middleware components are resolved, it's time to generate the final installable image. Tools such as [insert tools here] are installed from the Platform SDK. lvm2, atruncate, pigz and android-tools and it runs again build_packages.sh --mic with the variables RELEASE (Sailfish version) and EXTRA_NAME (build suffix) defined.

This produces a flashable image in ZIP which is usually stored in a directory like this:

$ANDROID_ROOT/SailfishOS-release-<version>-<device>-my1/

Inside you will find a file similar to SailfishOS--my1-<version>-<device>-<hw-version>.zip which you can then flash following the same official guides that Jolla publishes for the Xperia 10 IV/V and other supported models.

Special case: Xperia 10 (Android 9) and Xperia X

Although the general logic of HADK remains, devices based on Android 9 (Xperia 10, ganges family) and in Android 6/7 (Xperia X, Loire platform) They have important nuances: AOSP branches, manifests, template packages, and some vendor details change.

Xperia 10: Ganges family on Android 9 (Pie)

El Xperia 10 It relies on the Ganges hardware family and a base AOSP 9 (foot)A typical set of environment variables might include:

export VENDOR=sony
export DEVICE=i4113
export HABUILD_DEVICE=kirin
export FAMILY=ganges
export ANDROID_FLAVOUR=pie
export HAVERSION="sony-"$FAMILY"-aosp-"$ANDROID_FLAVOUR

These devices are used to clone projects such as droid-hal-sony-ganges-pie and the corresponding droid-config, the patterns are adjusted to include patterns-sailfish-consumer-generic y sailfish-porter-toolsRPMs are created using specific templates such as droid-system-sony-pie-template y droid-vendor-sony-pie-template.

The end result is once again a flashable ZIP file that is installed using Jolla's official instructions for Xperia 10, taking into account small details such as replacing @DEVICES@ for the correct uppercase value (e.g., I4113) and recalculate checksums if you touch the scripts.

Xperia X: veteran and highly polished support

El Xperia X (F5121/F5122) It was the first major target for Sailfish X and has a very polished adaptation. The build is based on AOSP branches corresponding to the firmware versions supported by Sony for this model, with builds 6.0.1 or 7.x identified by version numbers such as 34.3.Axyyy o 34.4.Axyyy.

It is very important to make sure that the Android build number It's one of those steps before unlocking the bootloader and flashing Sailfish. If the device has received a later update (for example, 34.5.Aqzzz or 35.xAqzzz), it's advisable downgrade using the Emma tool on Windows to revert to a supported build.

The official Jolla guide to install Sailfish X on Xperia X using Linux It details step by step: checking the bootloader, installing Fastboot, downloading and extracting the appropriate ZIP file, obtaining the binaries SW_binaries_for_Xperia_AOSP_M_MR1_3.10_v13_loire.imgcopy it to the same directory as the image and launch sudo bash ./flash.sh with the mobile phone in Fastboot mode.

This device also mentions a separate syspart system and specific RPMs for droid-system-f5121/f5122However, for practical purposes for the end user, it is enough to follow the official guide and make sure to use the Android build and binary combination recommended by Jolla.

Support status, typical problems, and how to ask for help

Jolla maintains up-to-date documentation on which models are officially supported, which devices have lost support, and which have unsupported community ports. It is important to distinguish between the Licensed images available at Jolla Shop and the community ports, which you can find in the Community Hardware Adaptations table.

If during installation or compilation you encounter strange errors (dependency failures, messages of build_packages.sh (which mention non-existent test suites, Fastboot errors due to USB, or network problems), a useful reference is the #sailfishos-porters channel on the OFTC networkwhere developers and advanced users share solutions to these cases.

Jolla also insists that any improvements made to the Sony's AOSP base This directly impacts the quality of Sailfish OS, which is why they refer to Sony's official guide for compiling AOSP 13 on Open Devices and offer specific scripts for flashing full AOSP with fastboot flashall, disabling verity and verifications in vbmeta and vbmeta_system when necessary.

If at any point you need to revert to a previous state because your mobile connectivity has been affected or something isn't working properly, the recommendation is Revert to Android using EmmaDouble-check that the phone works properly with the original system (calls, data, camera, GPS, WiFi, audio, touchscreen), and only then reinstall the latest Sailfish OS image following the official instructions for your model.

In short, if you understand the support status of your Xperia, respect the initial Android versions, take care of the bootloader, and follow the official steps to integrate the Sony binaries and flash the images, Installing Sailfish OS on a Sony Xperia is much easier than it initially seems.Whether you choose the simple route with official images or you're up for compiling your own builds with HADK and contributing to community ports. Share the guide and other people will learn about the topic.