Good morning guys. I was up until almost 3 AM yesterday to get this to work. I have managed to build an ARM64/aarch64 version of Figma Linux that will work on any ARM64 based SOC, including the Raspberry Pi 4, the PinePhone/PineBook, Rock Pis and so on.

As you can see from the screenshot above, I have it running on my Pi 4 that is running Ubuntu 20.10 Server, with i3wm. I had to jump through a few hoops to get this compiled and working, and I will try to detail them below.

Here's a question to the maintainers (@ChugunovRoman) - Is there any way that I can share the built .deb package so that it can be linked to the GitHub Releases page? I am willing to have my Pi dedicated to building new releases of Figma Linux for the Pi since I do not know of a free CI that builds for the ARM platform yet. For now, I have only built a .deb package, but I can also build an AppImage, .rpm, pacman or other packages as necessary, including an armhf or `armv7l' (ARM 32-bit hard float architecture) that should support Raspberry Pi OS 32-bit.

For anyone that wants to attempt this themselves, I am detailing the steps I took below:

First off, ensure that you have Node.js (preferably from Nodesource) installed. Then, git clone this repository.
cd into the directory. If you try installing the dependencies needed for the app to work now, it will probably fail as we do not have libfreetype6-dev installed on the system for this app to be built, especially if you are on Ubuntu or other Debian based distros. Solve this by installing
```
 sudo apt install libfreetype6-dev
```
Once done, you should now be in a position to install the dependencies. Install it by running
```
 npm i
```
The installation should take a while, and once it is done, you can build the app for production. However, figma-linux depends on node-sass which does not have any pre-built images for any of the ARM architectures (either armhf, or aarch64). In my previous comment this was a major road block for me, and I could not move further. While I tried the workaround I mentioned earlier, it meant that I would have to change core files (package.json) every time I needed to build for a new release of figma-linux which is not feasible and would likely break over time. The only sane option is to build node-sass from source to ensure that we stay 100% compliant with the upstream code of figma-linux.
Now let us build node-sass from source so that the build script can use this instead of complaining about an unsupported architecture. There are two ways of building it, and the easiest way is to run
```
 npm install node-sass
```
This should take a while to compile, but once done you should be good to actually start building the app for production. Build for production by running
```
 npm run build
```
At this point, you should have figma-linux built and ready for production, and you can check if everything works by running npm run start. However, this is pretty pointless as you cannot login (since it is not installed on the system, xdg-open cannot resolve any figma:// links to pass along the auth token back to your instance of figma-linux).
Let us remedy this by building a .deb package to install the app. Please note that this is a CPU intensive process, and if you are building this on a Pi 4, then you might want to have sufficient cooling (I have the official Pi 4 case and the official Pi 4 case fan which isn't the most efficient cooling system, but will do for now).

Now, there is a bug with fpm wherein it has hard-coded the architecture to be x86, which for our intents and purposes will not work. To work around this, let us install Ruby, and then install the fpm Ruby gem.
```
 sudo apt install ruby ruby-dev
 sudo gem install fpm -v 1.10.2 # We specify the version explicitly as v11+ has a bug that will not build proper `.deb` packages
```
Since we have a small single board computer, it is probably a good idea to edit our ./config/builder.json to remove the build targets that we don't need. Open up ./config/builder.json in a text editor and go to line 77 where you will find a list of all the targets. Let us replace this so that we will now only have one single target architecture:
```
    "target": [
         {
           "target": "deb",
           "arch": [
             "arm64"
           ]
         }
       ]
```
Save the file and quit. We can now build our .deb package. We need to let electron-builder know to use the fpm we installed from Ruby, and not download a binary from the internet during the build process. We do this like so:
```
 USE_SYSTEM_FPM=true npm run builder
```

At this point you should have a .deb package built and ready to be installed via apt or dpkg in figma-linux/builds/installer/.

Request - Make a version for aarch64 #133

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions