How To Install Figma on Manjaro

Figma has revolutionized collaborative design workflows, but Linux users often face challenges when trying to access this powerful design tool. While Figma doesn’t offer an official Linux client, Manjaro users have several reliable methods to run this essential design software on their systems. This comprehensive guide will walk you through the various installation options, configuration steps, and troubleshooting techniques to ensure a smooth Figma experience on your Manjaro system.

Table of Contents

Understanding Figma on Linux

Figma was originally designed as a browser-based interface design tool, making collaborative design work more accessible across platforms. This web-first approach means that technically, you can always access Figma through your browser on Manjaro. However, many designers prefer a dedicated desktop application for improved performance, offline capabilities, and better integration with their workflow.

For Linux users, including those on Manjaro, the community has developed several unofficial Figma clients. These applications essentially wrap the web version into a desktop experience while adding some native features. The primary project supporting this effort is Figma-Linux, which provides a solid desktop experience that closely resembles the official Windows and macOS applications.

When choosing how to install Figma on your Manjaro system, you have several options:

Installation via AUR (Arch User Repository)
Installation via Flatpak
Installation via Snap
Manual installation using package files or AppImage

Each method has its advantages and considerations, which we’ll explore in detail throughout this guide.

Prerequisites for Installing Figma on Manjaro

Before proceeding with any installation method, ensure your Manjaro system meets the necessary requirements and is properly prepared. Taking these preliminary steps will help avoid common issues during the installation process.

System Requirements Check:

A 64-bit Manjaro installation (x86_64 architecture)
At least 4GB RAM (8GB recommended for larger Figma projects)
Updated graphics drivers (especially important for WebGL support)
At least 1GB of free disk space
A stable internet connection

Update Your System:

Always begin with a fully updated system. Open your terminal and run:

sudo pacman -Syu

This command synchronizes your package databases and updates all installed packages to their latest versions. Performing this update ensures compatibility with newly installed software and reduces the likelihood of dependency issues.

Required Dependencies:

Depending on your installation method, you might need to install additional dependencies. For most Figma installations, these include:

sudo pacman -S --needed git base-devel

This command installs Git and the base development packages, which are necessary for AUR installations.

Backup Recommendation:

Before proceeding, it’s good practice to back up any important design files or configurations, especially if you’re migrating from another design tool or upgrading an existing Figma installation.

Installing Figma via AUR (Arch User Repository)

The Arch User Repository (AUR) is one of the strengths of Arch-based distributions like Manjaro. It contains user-contributed package build scripts that allow you to install software not found in the official repositories. For Figma, several packages are available in the AUR.

Installing an AUR Helper (if not already installed):

While you can install AUR packages manually, using an AUR helper like yay makes the process much simpler. If you don’t have yay installed:

sudo pacman -S --needed git base-devel
git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -si

Available Figma Packages in AUR:

The AUR offers several Figma-related packages:

figma-linux – Builds from source using the release tag
figma-linux-bin – Pre-built binary version from the release tag
figma-linux-git – Builds from the latest release tag on GitHub
figma-linux-dev-git – Builds from the latest commit on the dev branch

For most users, figma-linux-bin is recommended as it’s pre-compiled and typically more stable.

Installation Steps:

Open your terminal and search for available Figma packages:
```
yay -Ss figma
```
Install your preferred package, typically figma-linux-bin:
```
yay -S figma-linux-bin
```
During installation, you’ll be prompted to confirm the installation and possibly answer some configuration questions. The default options are usually sufficient.
Once installation completes, you can launch Figma from your application menu or by typing figma-linux in your terminal.

Post-Installation Configuration:

After installing, you may want to configure Figma to start automatically when you log in. This can be done through your desktop environment’s startup applications settings.

Installing Figma via Flatpak

Flatpak is a universal package management system that allows applications to be installed across different Linux distributions. Many users consider Flatpak the most reliable method for installing Figma on Linux systems.

Setting up Flatpak on Manjaro:

Flatpak comes pre-installed on Manjaro 20 or higher, but you may need to enable it:

Open the Software Manager (Add/Remove Programs) from your application menu
Click on the menu (three lines or dots, depending on your desktop environment) on the right
Select “Preferences” from the dropdown menu
Navigate to the “Flatpak” tab
Enable Flatpak support by sliding the toggle
It’s also recommended to enable automatic updates for Flatpak applications
Restart your system to complete the setup

Installing Figma using Flatpak:

Open your terminal and run:

flatpak install flathub io.github.Figma_Linux.figma_linux

When prompted, type ‘y’ to confirm the installation
Once installed, you can launch Figma from your application menu or by running:
```
flatpak run io.github.Figma_Linux.figma_linux
```

Advantages of the Flatpak Method:

Better isolation from your system, enhancing security
Self-contained dependencies, reducing conflicts with system libraries
Automatic updates through Flatpak’s update mechanism
Consistent experience across different Linux distributions

Font Configuration with Flatpak:

One limitation of Flatpak’s sandboxing is that it may not automatically detect all system fonts. To ensure Figma can access your fonts when installed via Flatpak, you may need to configure font access manually. This will be covered in the Font Configuration section later in this article.

Installing Figma via Snap

Snap is another universal package system developed by Canonical, the company behind Ubuntu. Figma is available as a Snap package, offering various release channels including stable, beta, and edge versions.

Enabling Snap Support on Manjaro:

Install Snapd and the libpamac-snap-plugin:
```
sudo pacman -S snapd libpamac-snap-plugin
```

Enable and start the Snapd service:

sudo systemctl enable --now snapd.socket

Create a symbolic link for classic snap support:
```
sudo ln -s /var/lib/snapd/snap /snap
```
Log out and log back in, or restart your system to ensure Snap’s paths are updated correctly.

Installing Figma using Snap:

Open your terminal and run:
```
sudo snap install figma-linux
```
Once installed, you can launch Figma from your application menu or by running:
```
snap run figma-linux
```

Accessing Local Fonts with Snap:

To use local fonts with the Snap version of Figma, create a symbolic link:

sudo ln -s $HOME/.local/share/fonts $HOME/snap/figma-linux/current/.local/share/

This ensures that Figma can access fonts installed in your user’s font directory.

Removing Figma Snap (if needed):

If you need to remove the Snap installation for any reason:

sudo snap remove figma-linux

Installing Using Package Files

If you prefer manual installation using package files, this option is also available for Figma on Manjaro.

AppImage Installation:

AppImage files are self-contained applications that run on most Linux distributions without installation. Figma is available as an AppImage:

Download the AppImage file from the Figma-Linux GitHub releases page
Make the AppImage executable:
```
chmod +x figma-linux-*.AppImage
```
Install it system-wide (optional but recommended):
```
sudo ./figma-linux-*.AppImage -i
```
This will install Figma on your system, after which you can run it from your application menu or terminal.

Notes on AppImage Installation:

The Figma AppImage is not fully portable – it installs components on your system
For more installation options, run ./figma-linux-*.AppImage -h
The AppImage version may require additional dependencies to be installed manually

Font Configuration in Figma

Proper font configuration is essential for design work in Figma. Here’s how to ensure Figma recognizes and can use all your system and custom fonts.

Understanding Font Directories in Manjaro:

Manjaro stores fonts in several locations:

System-wide fonts: /usr/share/fonts/
User fonts: ~/.local/share/fonts/ or ~/.fonts/

Installing Custom Fonts System-wide:

To install fonts system-wide for all users:

Create a directory for your font family:

sudo mkdir -p /usr/share/fonts/[font-name]

Copy font files to this directory:

sudo cp /path/to/font/files/* /usr/share/fonts/[font-name]/

Update the font cache:
```
sudo fc-cache -f -v
```

For example, to install Futura fonts:

sudo mkdir -p /usr/share/fonts/futura
sudo cp /path/to/futura/fonts/* /usr/share/fonts/futura
sudo fc-cache -f -v

Installing Fonts for a Single User:

To install fonts for your user only:

Create the fonts directory if it doesn’t exist:
```
mkdir -p ~/.local/share/fonts
```

Copy font files to this directory:

cp /path/to/font/files/* ~/.local/share/fonts/

Update the font cache:
```
fc-cache -f -v
```

Configuring Figma to Recognize System Fonts:

For Flatpak installations, you may need to grant Figma access to your font directories:

flatpak override --user --filesystem=~/.local/share/fonts:ro io.github.Figma_Linux.figma_linux
flatpak override --user --filesystem=/usr/share/fonts:ro io.github.Figma_Linux.figma_linux

For Snap installations, ensure the symbolic link is created as mentioned earlier:

sudo ln -s $HOME/.local/share/fonts $HOME/snap/figma-linux/current/.local/share/

Troubleshooting “No Fonts Found” Issues:

If Figma isn’t recognizing your fonts:

Verify fonts are properly installed by checking with:
```
fc-list | grep "font-name"
```
Restart Figma after installing new fonts
Clear Figma’s cache (covered in the troubleshooting section)
Ensure proper permissions for font directories

Troubleshooting Common Installation Issues

Even with careful installation, you might encounter some issues. Here are solutions to common problems when running Figma on Manjaro.

Fixing “Figma desktop app is out of date” Error:

This error typically occurs when the unofficial client hasn’t been updated to match Figma’s web version:

Clear the application cache:
```
rm -rf ~/.config/figma-linux/Cache/*
```
Update to the latest version of Figma-Linux using your installation method
If using AUR, try switching to the -git version for the latest updates
As a last resort, use Figma in your web browser until the desktop app is updated

Resolving WebGL and Rendering Issues:

If you experience graphical glitches or WebGL errors:

Ensure your graphics drivers are up to date:
```
sudo pacman -Syu
```
For NVIDIA graphics, make sure the appropriate drivers are installed:
```
sudo pacman -S nvidia nvidia-utils
```
For AMD graphics:
```
sudo pacman -S xf86-video-amdgpu
```
Try launching Figma with hardware acceleration disabled:
```
figma-linux --disable-gpu
```

Handling Text Input Problems:

Issues with text input, especially for non-English languages, can be frustrating:

Ensure your input method framework (IBus or Fcitx) is properly configured
Try launching Figma with these flags:
```
figma-linux --enable-ime
```

For Flatpak, grant additional permissions:

flatpak override --user --filesystem=xdg-run/app/org.freedesktop.portal.IBus:ro io.github.Figma_Linux.figma_linux

Addressing Application Crashes:

If Figma crashes frequently:

Launch from terminal to see error messages

Clear the cache and configuration:

rm -rf ~/.config/figma-linux/Cache/*
rm -rf ~/.config/figma-linux/GPUCache/*

Check system resources – Figma can be memory-intensive with large projects
Try a different installation method (e.g., switch from AUR to Flatpak)

Fixing Missing Dependencies:

If Figma fails to launch due to missing dependencies:

For AUR installations, reinstall with explicit dependency checking:
```
yay -S figma-linux-bin --needed
```
For AppImage, install common dependencies:
```
sudo pacman -S libxss libxtst nss gtk3
```

Performance Optimization for Figma on Manjaro

Optimizing Figma’s performance ensures smooth operation even with complex design projects.

Hardware Acceleration Settings:

Hardware acceleration can significantly improve performance but might cause issues on some systems:

To enable hardware acceleration (if disabled):
```
figma-linux --enable-gpu
```
To disable hardware acceleration (if causing issues):
```
figma-linux --disable-gpu
```

Memory Management Considerations:

Figma can be memory-intensive with large projects:

Close unnecessary browser tabs and applications when working with complex designs
Monitor memory usage with tools like htop:
```
sudo pacman -S htop
htop
```
Consider increasing your swap space if you have limited RAM

Multi-monitor Setup Optimizations:

For users with multiple displays:

If using different scaling factors, launch Figma with:
```
figma-linux --force-device-scale-factor=1
```
Try different display servers (X11 vs Wayland) if experiencing issues
For high-DPI displays, experiment with scaling options in your desktop environment

Browser vs. Desktop Application Performance:

Compare performance between the browser version and desktop application:

If the desktop app performs poorly, try Figma in Firefox or Chrome
For the browser version, consider using dedicated GPU profiles:
```
firefox --new-instance -P "figma" --no-remote
```

Keeping Figma Updated on Manjaro

Maintaining an up-to-date Figma installation ensures access to the latest features and security patches.

Update Procedures for Different Installation Methods:

For AUR installations:

yay -Syu figma-linux-bin

For Flatpak installations:

flatpak update io.github.Figma_Linux.figma_linux

or update all Flatpak applications:

flatpak update

For Snap installations:

sudo snap refresh figma-linux

For AppImage installations, download the latest AppImage from the GitHub releases page and replace your existing file.

Manual Update Considerations:

If automatic updates fail:

Remove the existing installation
Clear application caches and configurations if necessary
Reinstall using your preferred method
Reconfigure settings and font access

Congratulations! You have successfully installed Figma. Thanks for using this tutorial for installing the Figma on Manjaro Linux system. For additional help or useful information, we recommend you check the official Figma website.

VPS Manage Service Offer

If you don’t have time to do all of this stuff, or if this is not your area of expertise, we offer a service to do “VPS Manage Service Offer”, starting from $10 (Paypal payment). Please contact us to get the best deal!