Arch Linux (em dual boot)

Última atualização em jan. 1, 2023 30 minutos de leitura

Como meu trabalho de consultoria depende muito de ferramentas da Microsoft como o Office e o Power BI, tenho usado primariamente o Windows como sistema operacional.

Ainda programo bastante e, para minha surpresa, desenvolver no Windows tem sido muito bom. Quando preciso executar algo dependente do Linux como o Airflow e o Redmine, posso usar WSL e Docker.

Um dos problemas em virtualizar o Linux é a perda de performance. Por esse motivo separei uns 60GB para instalar o Arch em dual boot no meu notebook.

Escrevi no Twitter que estava instalando o Arch e me sugeriram atualizar meu guia antigo, pois muita coisa mudou em 8 anos. Então resolvi quebrar o hiato de mais de 3 anos deste blog para documentar meu novo processo de instalação.

Quando fiz meu post de 2012, a wiki oficial não estava atualizada. Hoje em dia ela está muito completa e eu recomendo segui-la para possíveis atualizações e mais detalhes.

Como nos posts anteriores, deixo claro que essas são as configurações que escolhi para os meus computadores (um Dell Latitude 3480 e um Acer Predator Helios 300).
Algumas configurações listadas aqui podem ser incompatíveis com o seu sistema ou simplesmente desnecessárias dependendo do Desktop Environment que você for utilizar.

Não copie e cole comandos sem entendê-los antes!

Não entrarei em muitos detalhes sobre os comandos utilizados. Mais informações sobre eles podem ser encontradas na internet e na wiki oficial.
Se você tiver alguma dúvida ou sugestão, fique à vontade para deixar um comentário aqui ou me mandar uma DM no Twitter.

Update: Desde maio de 2021, a imagem ISO do Arch inclui um instalador guiado chamado Archinstall. Como já estou acostumado, continuarei realizando o processo de instalação manual.

Particionamento do disco

Eu instalei o Windows primeiro e, durante a instalação, particionei o SSD de 240GB da seguinte forma:

  • 529 MB: Windows Recovery
  • 500 MB: EFI (maior do que o padrão)
  • 150 GB: Windows
  • 60 GB: Arch Linux
  • Restante: Partição NTFS criptografada com Veracrypt para acessar tanto do Linux quanto do Windows

Eu não criei uma partição para Swap. Se algum dia eu precisar, poderei criar um swap file no disco, em memória ou na memória da placa de vídeo.

Também deixei o /, o /home e o /var na mesma partição. O /boot será a partição EFI de 500 MB. Por padrão, o Windows cria essa partição com 100MB, porém isso pode não ser suficiente se você quiser carregar muitos módulos ou ter mais de um kernel.

Se eu não tivesse criado as partições pelo Windows, eu poderia usar alguma ferramenta do Linux como o cgdisk ou o parted

USB de instalação

Baixei a imagem ISO por BitTorrent e criei o USB bootável usando as opções default do Rufus Portable. Reinicei o computador e fiquei apertando F12 até aparecer a lista com a opção de boot pelo pendrive. Ao selecionar a opção de instalar o Arch, apareceu uma mensagem de esperando um disco com LABEL=ARCH202008. Eu simplesmente reconectei o pendrive à porta USB e o sistema carregou corretamente.

Layout do teclado

Ao cair no terminal, o primeiro passo é configurar o teclado. Como uso um teclado brasileiro, executei o seguinte comando:

  • Para teclado brasileiro:

    loadkeys br-abnt2

  • Para teclado americano:

    loadkeys us-acentos

Outras opções podem ser encontradas em ls /usr/share/kbd/keymaps/**/*.map.gz.

Atualização do relógio do sistema

timedatectl set-ntp true

O padrão do Linux é deixar o hardware clock em UTC, mas o padrão do Windows é usar o horário local. Prefiro deixar em UTC e configurar o Windows pelo Regedit.

Criptografia do disco

lsblk                       # Para descobrir a partição. /dev/sda5 no meu caso
cryptsetup -v luksFormat /dev/sda5

Eu achei as configurações padrão OK. Mais opções podem ser encontradas na wiki.

Se o lsblk não listar seu SSD (M.2 PCIe NVMe), verifique na BIOS se o SATA Mode está configurado para AHCI. Se o Windows foi instalado em modo RAID, você terá que reiniciá-lo em safe mode e alterar o SATA Mode na BIOS.

Formatação da partição raíz

cryptsetup luksOpen /dev/sda5 arch
mkfs.ext4 -L arch /dev/mapper/arch

Montagem das partições

mount /dev/mapper/arch /mnt
mkdir /mnt/boot
mount /dev/sda2 /mnt/boot

Conexão com a Internet

  • Wifi

    Conecte-se ao wifi usando o iwd

    iwctl --passphrase MINHA_SENHA station wlan0 connect MEU_SSID

  • Cabo

    Redes cabeadas devem funcionar automaticamente. Se não for o caso:

    • Configure um IP estático com o Iproute2

    • Pegue um IP dinâmico por DHCP: systemctl start dhcpcd@enp2s0.

      Use ip link para obter o nome da interface.

Mirrorlist

O Pacman lê o arquivo /etc/pacman.d/mirrorlist para definir de quais mirrors baixar os pacotes. É bom deixar os mais atualizados e mais rápidos no topo para os downloads não demorarem muito.

O novo instalador do Arch deve fazer isso automaticamente usando o Reflector assim que a conexão com a internet for detectada. Apenas verifique se está tudo OK. Como estou em São Paulo, os mirrors da UFSCar e UFPR ficaram no topo.

Instalação dos principais pacotes

Neste passo eu instalo o sistema base e todos os pacotes que precisarei, como ferramentas de rede, editor de texto, páginas de manual, Xorg e PulseAudio.

pacstrap /mnt \
    base{,-devel} \
    linux{,-firmware} \

    intel-ucode \

    iwd \
    dhcpcd \
    iputils \

    zsh \
    go \
    git \
    neovim \
    python{,-pip,-pynvim} \

    man-db \
    man-pages \
    texinfo \

    xorg-server \
    xorg-xinit \
    xf86-video-intel \
    xf86-input-synaptics \

    alsa-utils \
    pipewire{,-pulse}
    wireplumber
    # pulseaudio{,-alsa,-bluetooth} \
    # pavucontrol

Fstab

genfstab -U -p /mnt >> /mnt/etc/fstab

Chroot

arch-chroot /mnt

Timezone

  • Brasil

    ln -sf /usr/share/zoneinfo/America/Sao_Paulo /etc/localtime

  • Alemanha

    ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime

Salve o horário:

hwclock --systohc

Localização

Eu uso o sistema em inglês, mas também habilito o pt_BR e o de_DE. Eu tendo a preferir o en_GB ao en_US, mas isso é questão de gosto.

sed -i -e 's/#en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen
sed -i -e 's/#en_GB.UTF-8 UTF-8/en_GB.UTF-8 UTF-8/' /etc/locale.gen
sed -i -e 's/#pt_BR.UTF-8 UTF-8/pt_BR.UTF-8 UTF-8/' /etc/locale.gen
sed -i -e 's/#de_DE.UTF-8 UTF-8/de_DE.UTF-8 UTF-8/' /etc/locale.gen
locale-gen
echo LANG=en_US.UTF-8 > /etc/locale.conf

Virtual Console

Configura o layout do teclado e a fonte.

echo -e "KEYMAP=br-abnt2\nFONT=latarcyrheb-sun16" > /etc/vconsole.conf

ou

echo -e "KEYMAP=us-acentos\nFONT=latarcyrheb-sun16" > /etc/vconsole.conf

Configuração de rede

Adiciona o nome do computador no /etc/hosts e também bloqueia alguns sites maliciosos e de propagandas.

echo "nome_do_computador" > /etc/hostname
curl --output /etc/hosts --url "https://someonewhocares.org/hosts/zero/hosts"
echo -e "127.0.1.1\tnome_do_computador.localdomain\tnome_do_computador" >> /etc/hosts

Initramfs

Adicionei encrypt, pois a partição do sistema é criptografada.

Também carrego os módulos da Nvidia, como explicado mais abaixo.

$ nvim /etc/mkinitcpio.conf
  HOOKS=(base udev autodetect modconf block encrypt filesystems keyboard keymap consolefont fsck)

mkinitcpio -p linux

Pacman

Adiciona o repositório multilib, colore o pacman e adiciona a animação do Pac-Man.

sed -i -e '/^#\[multilib\]$/,+1s/#//' /etc/pacman.conf
sed -i -e '/# Misc options/a ILoveCandy' /etc/pacman.conf
sed -i -e 's/^# Color/Color/' /etc/pacman.conf

Senha do root

passwd

DNS e rede

É possível usar o Iproute2, o wpa_supplicant ou o Iwd diretamente para se conectar a redes cabeadas e sem fio, porém um gerenciador de conexões facilita o processo.

Algumas configurações que já usei:

  • NetworkManager

    O NetworkManager foi criado pela RedHat e agora faz parte do projeto GNOME.

    Ele permite configurar redes cabeadas, wifi, modems e VPNs tanto por linha de comando quanto por interfaces gráficas (muito bem integradas ao Gnome e KDE).

    sudo pacman -S networkmanager
sudo systemctl enable NetworkManager.service

    $ nmcli device
DEVICE             TYPE      STATE         CONNECTION
enp7s0             ethernet  disconnected  --
wlp0s20f3          wifi      disconnected  --
p2p-dev-wlp0s20f3  wifi-p2p  disconnected  --
lo                 loopback  unmanaged     --

    $ nmcli connection add type ethernet con-name Casa ifname enp7s0
Connection 'Casa' (0acb09e3-40a4-479f-9532-a154d8d65dfc) successfully added.

    $ nmcli connection up Casa
Connection successfully activated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/1)

    $ nmcli device disconnect enp7s0
Device 'enp7s0' successfully disconnected.

    Obs.: é possível manter tanto o cabo quanto o wifi conectados ao mesmo tempo de forma que se você desconectar o cabo, não haverá downtime.

    $ nmcli device wifi list
IN-USE  BSSID              SSID       MODE   CHAN  RATE        SIGNAL  BARS  SECURITY
        7C:05:07:04:38:52  MEU_SSID   Infra  4     130 Mbit/s  80      ▂▄▆_  WPA2
        A4:33:D7:A7:EA:10  Vizinho 1  Infra  6     130 Mbit/s  70      ▂▄▆_  WPA2
        C0:3D:D9:88:1E:00  Vizinho 2  Infra  1     130 Mbit/s  65      ▂▄▆_  WPA2
        68:02:B8:28:9A:60  Vizinho 3  Infra  6     195 Mbit/s  60      ▂▄▆_  WPA1 WPA2
        00:26:F2:6B:D6:F2  Vizinho 4  Infra  11    54 Mbit/s   59      ▂▄▆_  WPA1 WPA2

    $ nmcli device wifi connect MEU_SSID password MINHA_SENHA
Device 'wlp0s20f3' successfully activated with '3eafc7d7-8a89-40ae-8b01-ade3ba474de0'.

    $ nmcli connection show
NAME      UUID                                  TYPE      DEVICE
MEU_SSID  3eafc7d7-8a89-40ae-8b01-ade3ba474de0  wifi      wlp0s20f3
Casa      0acb09e3-40a4-479f-9532-a154d8d65dfc  ethernet  --

    ls /etc/NetworkManager/system-connections/
Casa.nmconnection  MEU_SSID.nmconnection

  • systemd-networkd + systemd-resolved + iwd

    ln -sf /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf

    $ nvim /etc/iwd/main.conf
[General]
EnableNetworkConfiguration=true
[Network]
NameResolvingService=systemd

    A rede pode ser iniciada ao ligar o computador:

    sudo systemctl enable systemd-resolved iwd

  • Wicd

Usuários

~# useradd -m -g users -G wheel,storage,power,video,audio,rfkill -s /bin/zsh julio
~# passwd julio
~# EDITOR=nvim visudo
Descomente a linha `%wheel ALL=(ALL) ALL`

Bootloader

Estou usando o systemd-boot. Como meu processador é Intel, também carrego seu microcode.

~# bootctl install

~# nvim /boot/loader/entries/arch.conf
title   Arch Linux
linux   /vmlinuz-linux
initrd  /intel-ucode.img
initrd  /initramfs-linux.img
options cryptdevice=UUID=0a1b2c3d-…-4e5f6g:arch root=/dev/mapper/arch rootfstype=ext4 add_efi_memmap

sudo nvim /boot/loader/loader.conf
timeout 3

O UUID da partição criptografada (/dev/sda5) pode ser visto executando o comando lsblk -o +UUID.

Com o bootloader configurado, já podemos reiniciar o computador. Se tudo der certo, aparecerá um menu para escolher o sistema operacional.

sudo umount /mnt/boot
sudo umount /mnt
sudo systemctl reboot

Se nenhum display manager foi instalado, o Arch iniciará no terminal. Entre com o usuário criado na etapa anterior.

Dotfiles

Meus dotfiles estão disponíveis no Github. Eu clono o repositório e crio os symlinks apropriados. Quando eu tiver tempo, vou usar o rcm, chezmoi ou o GNU Stow para automatizar isso.

~$ git clone https://github.com/jbsilva/dotfiles.git

~$ ln -s dotfiles/.config ~/.config
~$ ln -s dotfiles/.zsh ~/.zsh
~$ ln -s dotfiles/.zshrc ~/.zshrc
~$ ln -s dotfiles/.gitconfig ~/.gitconfig
~$ ln -s dotfiles/.p10k_console.zsh ~/.p10k_console.zsh
~$ ln -s dotfiles/.p10k.zsh ~/.p10k.zsh
~$ ln -s dotfiles/.xinitrc ~/.xinitrc
~$ ln -s dotfiles/XCompose/.XCompose ~/.XCompose
~$ ln -s dotfiles/bin ~/bin

Shell

Existem muitas opções de shell de linha de comando, como Bash, Zsh, KornShell, e Fish. Para listar os shells instalados execute o comando chsh -l.

Eu uso o Zsh há anos. Ele é POSIX compliant e fica extremamente amigável com alguns plugins (PowerLevel10k, etc.), que meu dotfile instala e configura automaticamente com o zplug.

Eu criei meu usuário com o parâmetro -s /bin/zsh, mas é possível trocar o shell padrão com o comando chsh -s full-path-to-shell.

Emuladores de Terminal

Existem muitos terminal emulators disponíveis para Linux, cada um com suas vantagens e desvantagens.

Eu costumava usar o urxvt, porque antigamente tempo de inicialização e uso de memória eram os principais fatores para mim. Agora que tenho computadores mais potentes, outras features se destacam:

  • Multi plataforma (pelo menos Linux e macOS)
  • Unicode
  • Truecolor
  • Ligatures
  • Tabs
  • GPU accelerated
  • Boa documentação

De todos que testei, o Kitty é o que tem mais funcionalidades. Infelizmente ele não é perfeito, tem phone home features, usa um terminfo próprio que causa problemas e o desenvolvedor frequentemente se comporta de forma rude.

O Alacritty é bom, mas ele não tem tabs e talvez nunca tenha.

Multiplexadores de Terminal

Emuladores de terminal como o Kitty permitem dividir uma única janela em vários terminais, porém a maioria dos multiplexadores de terminal fazem isso e muito mais, como permitir deixar uma sessão rodando mesmo após fechar o terminal.

Alguns que já usei:

  • GNU Screen
    • É o mais simples e já vem instalado em várias distribuições.
  • Tmux
  • Byobu
    • É uma camada sobre o Screen ou Tmux. Gosto bastante, mas o projeto foi descontinuado em fevereiro de 2020.
  • Zellij
    • Meu atual favorito. É um projeto novo (em 2020 se chamava Mosaic) escrito em Rust e com muitas features interessantes.

Yay

O Yay é um AUR helper/Pacman wrapper escrito em Go que ajuda bastante na instalação de pacotes.

$ git clone https://aur.archlinux.org/yay.git && \
    cd yay && \
    makepkg -sri && \
    cd .. && \
    rm -rf yay

Alguns pacotes extras que eu instalo, incluindo o terminal Kitty, o editor de imagens Gimp, o VS Code e diversos utilitários:

$ yay -S \
    ack \
    aws-cli-v2-bin \
    bleachbit \
    bluez \
    bluez-utils \
    calibre \
    chromium \
    code \
    ctags \
    dbeaver \
    digikam \
    discord \
    docker-compose \
    duf \
    dust \
    fcitx5-chinese-addons \
    fcitx5-im \
    ffmpeg \
    firefox \
    gimp \
    gitahead \
    goldendict \
    gparted \
    htop \
    hugo \
    imagemagick \
    insomnia-bin \
    jq \
    kitty \
    lens-bin \
    libreoffice-fresh \
    make \
    meld \
    neofetch \
    nerd-fonts-hack \
    noto-fonts-emoji \
    npm \
    ntfs-3g \
    oath-toolkit \
    obs-studio \
    okular \
    openssh \
    p7zip \
    polkit \
    qalculate-gtk \
    renameutils \
    rsync \
    rust-analyzer \
    slack-desktop \
    spotify \
    sshfs \
    telegram-desktop \
    texlive-core \
    texlive-latexextra \
    thunderbird \
    transmission-remote-gtk \
    tree \
    ttf-joypixels \
    usbutils \
    veracrypt \
    vlc \
    wget \
    xclip \
    xorg-xrandr \
    # audacity \
    # awesome-git \
    # aws-cli \
    # blueman \
    # byobu \
    # copyq \
    # feh \
    # gnome-keyring \
    # graphviz \
    # hdparm \
    # ibus \
    # ibus-libpinyin \
    # kdenlive \
    # light-git \
    # macchanger \
    # maim \
    # picom-git \
    # postman-bin \
    # redshift \
    # rofi-git \
    # sshpass \
    # teams \
    # unrar \
    # unzip

Firewall

sudo pacman -S nftables
sudo systemctl enable nftables.service
sudo nft list ruleset

Fontes

Instale as fontes disponíveis no repositório oficial ou no AUR:

$ yay -S \
    inter-font \
    nerd-fonts-fantasque-sans-mono \
    noto-fonts \
    noto-fonts-cjk \
    noto-fonts-emoji \
    otf-san-francisco \
    otf-sfmono-patched \
    ttf-dejavu \
    ttf-liberation \
    ttf-meslo-nerd-font-powerlevel10k

Instalação manual

Fontes não disponíveis como pacotes podem ser instaladas manualmente. Basta adicionar os arquivos em alguma subpasta de /usr/local/share/fonts (para todos os usuários) ou ~/.local/share/fonts/ (apenas para o seu usuário).

Exemplo:

sudo mkdir -p /usr/local/share/fonts/{otf,ttf}

wget http://www.exljbris.com/dl/fontin2_pc.zip
sudo 7z x fontin2_pc.zip -o/usr/local/share/fonts/ttf/Fontin

sudo find /usr/local/share/fonts -type d -exec chmod 755 {} \;
sudo find /usr/local/share/fonts -type f -exec chmod 644 {} \;

$ tree /usr/local/share/fonts
/usr/local/share/fonts
├── otf
│   └── Example_Sans
│       ├── Example_Sans_B.otf
│       ├── Example_Sans_BI.otf
│       ├── Example_Sans_I.otf
│       └── Example_Sans_R.otf
└── ttf
    └── Fontin
        ├── Fontin-Bold.ttf
        ├── Fontin-Italic.ttf
        ├── Fontin-Regular.ttf
        ├── Fontin-SmallCaps.ttf
        └── ReadMe.txt

fc-cache
fc-list
…

Se quiser definir fontes específicas a serem usadas, edite o arquivo $XDG_CONFIG_HOME/fontconfig/fonts.conf.

Fontes do Windows

Você pode obter as fontes da ISO ou da pasta C:\Windows\Fonts de um Windows instalado.

Copie as fontes para /usr/share/fonts/WindowsFonts:

sudo mkdir /usr/share/fonts/WindowsFonts
sudo cp /c/Windows/Fonts/* /usr/share/fonts/WindowsFonts/
sudo chmod 644 /usr/share/fonts/WindowsFonts/*

Alternativamente, use um pacote como o ttf-ms-win10 ou o ttf-ms-win11.

git clone https://aur.archlinux.org/ttf-ms-win11
cd ttf-ms-win11
cp /c/Windows/System32/Licenses/neutral/_Default/Core/license.rtf .
cp /c/Windows/Fonts/* .
makepkg -si

Teclados

O teclado do meu notebook é ABNT2, porém às vezes eu conecto teclados com outros layouts.

É possível configurar cada teclado individualmente pelo device id ou alternar entre perfis pré configurados.

  1. Pegue o device id do teclado

    sudo pacman -S xorg-xinput

    $ xinput -list | grep -i Keychron
⎜   ↳ Keychron Keychron K2  id=11  [slave pointer  (2)]
    ↳ Keychron Keychron K2  id=10  [slave keyboard (3)]
    ↳ Keychron Keychron K2  id=19  [slave keyboard (3)]

    $ xinput list-props 10
Device 'Keychron Keychron K2':
    Device Enabled (189):    1
    Device Node (313):   "/dev/input/event5"

    $ ls -l /dev/input/by-id/usb-Keychron*
… /dev/input/by-id/usb-Keychron_Keychron_K2-event-if01 -> ../event6
… /dev/input/by-id/usb-Keychron_Keychron_K2-event-kbd -> ../event5

  2. Configure com o setxkbmap

    $ setxkbmap -device `xinput -list | \
    grep "Keychron K2.*keyboard" | \
    sed -e 's/^.*id=\([0-9]\+\).*/\1/' | \
    head -1` \
           -layout us              \
           -variant intl           \
           -option lv3:ralt_switch \
           -option compose:rctrl    \
           -option caps:swapescape

    Use os comandos localectl list-x11-keymap-layouts, localectl list-x11-keymap-variants us, localectl list-x11-keymap-options e o arquivo /usr/share/X11/xkb/rules/base.lst para definir a configuração adequada.

    Meu exemplo troca o CapsLock com o Esc, usa o control da direita como a tecla compose (Multi_Key) e o Alt da direita para o terceiro nível.

  3. Execute o comando ao iniciar o sistema

    $ nvim ~/bin/keyboards.sh
#!/bin/sh

# Notebook keyboard
keyboard_id=$(
    xinput -list |
    grep "AT Translated Set 2 keyboard.*keyboard" |
    sed -e 's/^.*id=\([0-9]\+\).*/\1/' |
    head -1
)
if [ ! -z "$keyboard_id" ]; then
    setxkbmap -device $keyboard_id    \
              -layout br              \
              -option lv3:ralt_switch \
              -option compose:menu    \
              -option caps:swapescape
fi

# Keychron K2
keyboard_id=$(
    xinput -list |
    grep "Keychron K2.*keyboard" |
    sed -e 's/^.*id=\([0-9]\+\).*/\1/' |
    head -1
)
if [ ! -z "$keyboard_id" ]; then
    setxkbmap -device $keyboard_id    \
              -layout us              \
              -variant intl           \
              -option lv3:ralt_switch \
              -option compose:rctrl   \
              -option caps:swapescape
fi

    $ nvim ~/.config/autostart/keyboards.sh.desktop
[Desktop Entry]
Exec=/home/julio/bin/keyboards.sh
Icon=dialog-scripts
Name=keyboards.sh
Path=
Type=Application
X-KDE-AutostartScript=true

  4. Compose: cê-cedilha

    No layout US International with Dead Keys, o ç pode ser obtido com AltGr + ,, porém eu prefiro usar ´ + c ou compose + c.

    Crie um ~/.XCompose (ou ~/.config/ibus/Compose) baseado no /usr/share/X11/locale/en_US.UTF-8/Compose:

    # UTF-8 (Unicode) compose sequence
include "%L"
<Multi_key> <c>   : "ç"   ccedilla
<Multi_key> <C>   : "Ç"   Ccedilla
<dead_acute> <c>  : "ç"   ccedilla
<dead_acute> <C>  : "Ç"   Ccedilla
<Multi_key> <t> <o> <w> <e> <r>  : "🗼"

Caracteres orientais

É possível digitar caracteres indisponíveis no seu teclado através de um input method framework como o IBUS ou o Fcitx5.

Vou mostrar como usar o ibus-libpinyin e o fcitx5-chinese-addons para digitar em chinês. A configuração de outros idiomas usando outros IMEs (input method editors) é semelhante.

IBUS

O IBus (Intelligent Input Bus) é bastante popular. Ele inclusive já vem integrado ao GNOME, mas também funciona bem com outros Desktop Environments.

  1. Instale o IBus

    sudo pacman -S ibus ibus-libpinyin

  2. Defina as seguintes variáveis de ambiente:

    sudo nvim /etc/environment
GTK_IM_MODULE=ibus
QT_IM_MODULE=ibus
XMODIFIERS=@im=ibus
GLFW_IM_MODULE=ibus

  3. Configure o IBus para iniciar com o DE

    $ nvim ~/.config/autostart/ibus-daemon.desktop
[Desktop Entry]
Comment=IBus Daemon
#Exec=ibus-daemon -drx --panel=/usr/lib/kimpanel-ibus-panel
Exec=ibus-daemon -drx
GenericName=IBus Daemon
Icon=ibus-engine
Name=IBus Daemon
StartupNotify=true
Terminal=true
Type=Application
X-KDE-SubstituteUID=false

    O KDE possui um widget chamado Input Method Panel, porém eu prefiro usar o painel padrão do IBus mesmo.

  4. Configure o o IBus

    ibus-setup

    Em Input Method, escolha Portuguese (Brazil), Chinese-Intelligent Pinyin e English (US, intl., with dead keys).

    Em General, configure o atalho <Super>space para alternar entre os input methods.

    Em Advanced, marque a opção de usar o layout do sistema para que o IBus não sobrescreva o layout definido usando o setxkbmap.

  5. Mude a cor do painel para combinar com sua taskbar

    gsettings set org.freedesktop.ibus.panel xkb-icon-rgba '#ffffff'

Fcitx5

O Fcitx (Flexible Context-aware Input Tool with eXtension support) é o input method framework que eu uso.

Ele é bastante flexível, tem muitos recursos e se integra bem com o KDE.

  1. Instale o Fcitx5

    sudo pacman -S fcitx5-im fcitx5-chinese-addons

  2. Defina as seguintes variáveis de ambiente:

    sudo nvim /etc/environment
GTK_IM_MODULE=fcitx
QT_IM_MODULE=fcitx
XMODIFIERS=@im=fcitx
DefaultIMModule=fcitx
SDL_IM_MODULE=fcitx
GLFW_IM_MODULE=ibus

    A última linha é para o Kitty. Ela fica como ibus mesmo.

  3. Configure o Fcitx5 para iniciar com o DE

    $ nvim ~/.config/autostart/fcitx5.desktop
[Desktop Entry]
Name=Fcitx5
GenericName=Fcitx5 Input Method
Comment=Start Fcitx5
Exec=fcitx5
Icon=fcitx
Terminal=false
Type=Application
Categories=System;Utility;
StartupNotify=false
X-GNOME-Autostart-Phase=Applications
X-GNOME-AutoRestart=false
X-GNOME-Autostart-Notify=false
X-KDE-autostart-after=panel
X-KDE-StartupNotify=false
X-GNOME-Autostart-enabled=true

  4. Configure o Fcitx5

    Recomendo realizar as configurações pela interface gráfica fcitx5-configtool (no KDE ele fica integrado às configurações do sistema em System Settings » Personalization » Regional Settings » Input Method).

    Nos meus testes, os arquivos editados manualmente acabaram sendo sobrescritos com os valores configurados pela interface gráfica.

    • Config

      $ nvim ~/.config/fcitx5/config
[Hotkey/TriggerKeys]
0=Super+space

[Behavior/DisabledAddons]
0=cloudpinyin
1=wayland
2=waylandim

    • Layouts

      $ nvim ~/.config/fcitx5/profile
[Groups/0]
# Group Name
Name="Group 1"
# Layout
Default Layout=us-intl
# Default Input Method
DefaultIM=keyboard-us-intl

[Groups/0/Items/0]
# Name
Name=keyboard-us-intl
# Layout
Layout=

[Groups/0/Items/1]
# Name
Name=pinyin
# Layout
Layout=

[GroupOrder]
0="Group 1"

      Obs.: a última entrada na configtool será o DefaultIM.

    • XCB

      $ nvim ~/.config/fcitx5/conf/xcb.conf
Allow Overriding System XKB Settings=False

    • UI

      pacman -S fcitx5-material-color fcitx5-nord

      $ nvim ~/.config/fcitx5/conf/classicui.conf
# Use Per Screen DPI
PerScreenDPI=False
# Font
Font="Noto Sans Black 10"
# Menu Font
MenuFont="Sans 10"
# Theme
Theme=Material-Color-Blue

    • Cloud Pinyin

      $ nvim ~/.config/fcitx5/conf/pinyin.conf
CloudPinyinEnabled=False

Teclado Keychron

Para fazer as teclas F1,…,F12 funcionarem corretamente:

sudo nvim /etc/modprobe.d/hid_apple.conf
options hid_apple fnmode=2

sudo mkinitcpio -P

XDG user directories

Instale o xdg-user-dirs para criar as pastas.

sudo pacman -S xdg-user-dirs
$ xdg-user-dirs-update --force

Gerenciamento de energia

Existem muitas ferramentas para gerenciamento de energia. Eu uso as seguintes:

sudo pacman -S tlp acpid acpi_call upower xfce4-power-manager
sudo systemctl enable tlp.service
sudo systemctl enable acpid.service

Bluetooth

Após instalar o bluez, inicie o bluetooth.service:

sudo systemctl start bluetooth.service

A configuração do Bluez fica em /etc/bluetooth/main.conf. Eu uso as configurações padrão.

A maioria dos desktop environments incluem alguma GUI para facilitar a conexão, como o Bluedevil no KDE, mas eu também gosto de instalar o bluez-utils para conectar dispositivos bluetooth pela linha de comando com o bluetoothctl.

Exemplo conectando dois teclados e um fone de ouvido:

$ bluetoothctl
Agent registered

[bluetooth]# power on
[CHG] Controller 8C:8D:28:F7:3A:77 Class: 0x007c010c
Changing power on succeeded
[CHG] Controller 8C:8D:28:F7:3A:77 Powered: yes

[bluetooth]# scan on
Discovery started
[CHG] Controller 8C:8D:28:F7:3A:77 Discovering: yes
[NEW] Device 20:20:01:07:B1:89 Bluetooth 3.0 Keyboard
[NEW] Device DC:2C:26:FF:24:BD Keychron K2
[NEW] Device 60:F4:3A:12:8E:02 EDIFIER W800BT

[bluetooth]# pair 20:20:01:07:B1:89
Attempting to pair with 20:20:01:07:B1:89
[CHG] Device 20:20:01:07:B1:89 Connected: yes
[agent] PIN code: 428084
[CHG] Device 20:20:01:07:B1:89 Modalias: usb:v04E8p7021d011B
[CHG] Device 20:20:01:07:B1:89 UUIDs: …
[CHG] Device 20:20:01:07:B1:89 ServicesResolved: yes
[CHG] Device 20:20:01:07:B1:89 Paired: yes
Pairing successful

[bluetooth]# trust 20:20:01:07:B1:89
[CHG] Device 20:20:01:07:B1:89 Trusted: yes
Changing 20:20:01:07:B1:89 trust succeeded

[bluetooth]# connect 20:20:01:07:B1:89
Attempting to connect to 20:20:01:07:B1:89
[CHG] Device 20:20:01:07:B1:89 Connected: yes
Connection successful

[Bluetooth 3.0 Keyboard]# pair 60:F4:3A:12:8E:02
Attempting to pair with 60:F4:3A:12:8E:02
[CHG] Device 60:F4:3A:12:8E:02 Connected: yes
[CHG] Device 60:F4:3A:12:8E:02 UUIDs: …
[CHG] Device 60:F4:3A:12:8E:02 ServicesResolved: yes
[CHG] Device 60:F4:3A:12:8E:02 Paired: yes
Pairing successful

[Bluetooth 3.0 Keyboard]# trust 60:F4:3A:12:8E:02
[CHG] Device 60:F4:3A:12:8E:02 Trusted: yes
Changing 60:F4:3A:12:8E:02 trust succeeded

[Bluetooth 3.0 Keyboard]# connect 60:F4:3A:12:8E:02
Attempting to connect to 60:F4:3A:12:8E:02
Connection successful

[EDIFIER W800BT]# pair DC:2C:26:FF:24:BD
Attempting to pair with DC:2C:26:FF:24:BD
[CHG] Device DC:2C:26:FF:24:BD Connected: yes
[CHG] Device DC:2C:26:FF:24:BD Modalias: usb:v05ACp024Fd011B
[CHG] Device DC:2C:26:FF:24:BD UUIDs: 00001000-0000-1000-8000-00805f9b34fb
[CHG] Device DC:2C:26:FF:24:BD UUIDs: 00001124-0000-1000-8000-00805f9b34fb
[CHG] Device DC:2C:26:FF:24:BD UUIDs: 00001200-0000-1000-8000-00805f9b34fb
[CHG] Device DC:2C:26:FF:24:BD ServicesResolved: yes
[CHG] Device DC:2C:26:FF:24:BD Paired: yes
Pairing successful
[CHG] Device DC:2C:26:FF:24:BD WakeAllowed: yes
[CHG] Device DC:2C:26:FF:24:BD ServicesResolved: no
[CHG] Device DC:2C:26:FF:24:BD Connected: no

[EDIFIER W800BT]# trust DC:2C:26:FF:24:BD
[CHG] Device DC:2C:26:FF:24:BD Trusted: yes
Changing DC:2C:26:FF:24:BD trust succeeded

[EDIFIER W800BT]# connect DC:2C:26:FF:24:BD
Attempting to connect to DC:2C:26:FF:24:BD
[CHG] Device DC:2C:26:FF:24:BD Connected: yes
Connection successful

[Keychron K2]# paired-devices
Device 60:F4:3A:12:8E:02 EDIFIER W800BT
Device 20:20:01:07:B1:89 Bluetooth 3.0 Keyboard
Device DC:2C:26:FF:24:BD Keychron K2

[Keychron K2]# quit

Dica: Use FN+Z+J para resetar o teclado Keychron e redefinir as conexões.

asdf

O asdf possui plugins para quase qualquer coisa. Ele é capaz de substituir o pyenv, rbenv, goenv e nvm. Existe até um plugin para gerenciar diferentes versões do Poetry.

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.11.3

Use o plugin do oh-my-zsh para ativar e adicionar completions.

  • Python

    pacman -S --needed base-devel openssl zlib xz tk

    asdf plugin add python
asdf install python latest:3
asdf global python latest

    asdf install python latest:3.10
asdf local python latest:3.10
asdf uninstall python <python-version>

  • Ruby

    asdf plugin add ruby
asdf install ruby latest
asdf local ruby latest

  • Go

    asdf plugin add golang
asdf install golang latest
asdf global golang latest

  • Node.js

    asdf plugin add nodejs
asdf install nodejs latest

As versões globais são definidas no arquivo ~/.tool-versions.

Python

Eu tive meu primeiro contato com Python há mais de 10 anos e hoje, além de ser minha linguagem de programação favorita, ela é a linguagem que mais uso para trabalho e projetos pessoais.

O Zen do Python diz:

“There should be one– and preferably only one –obvious way to do it.”

O que é válido para código, mas para packaging a história é bem diferente. Meus sentimentos são bem retratados nessa sequência de tiras do xkcd: xkcd 353, xkcd 927, xkcd 1987.

xkcd 927
xkcd 927

Minhas preferências atuais são as seguintes, em ordem:

  • Para gerenciar diferentes versões do Python: asdf ou Pyenv.

  • Para gerenciar ambientes virtuais, controlar dependências e facilitar a publicação de pacotes: PDM ou Poetry.

  • Para casos mais complexos de machine learning ou projetos que dependam de pacotes e binários que não estão disponíveis no pypi: Mambaforge.

  • IDE: VSCode com a extensão oficial ou PyCharm.

    O problema do PyCharm é que algumas funcionalidades importantes (integração com frameworks, edição de SQL, integração com Docker, etc.) são pagas.

Pyenv

O Pyenv permite instalar e usar diferentes versões do Python.

Ele é como o asdf, porém exclusivo para Python. Se você já usa o asdf para outras linguagens talvez não faça muito sentido instalar o Pyenv.

  1. Instale o Pyenv:

    sudo pacman -S pyenv

  2. Opcionalmente, também instale o pyenv-virtualenv:

    yay -S pyenv-virtualenv

  3. Adicione as seguintes linhas ao ~/.zshrc:

    if (( $+commands[pyenv] )); then eval "$(pyenv init --path)"; fi
if (( $+commands[pyenv-virtualenv-init] )); then eval "$(pyenv virtualenv-init -)"; fi

  4. Verifique quais versões estão disponívels e instale as que for usar:

    pyenv install --list
pyenv install 3.8.12
pyenv install mambaforge

  5. Liste as versões instaladas

    pyenv versions

  6. Na pasta de algum projeto, defina a versão a ser usada

    pyenv local 3.8.12

    Um arquivo chamado .python-version será criado:

    $ cat .python-version
3.8.12

Poetry

Update: sessão atualizada para a versão 1.2.

  1. Instale o Poetry

    Eu prefiro não usar o gerenciador de pacotes do sistema para o Poetry, existem algumas boas alternativas:

    • Script:

      wget -O install-poetry.py https://install.python-poetry.org
python install-poetry.py --preview

      Obs.: O antigo instalador (get-poetry.py) foi substituido pelo install-poetry.py. Não passe o parâmetro --preview se quiser a última versão estável.

    • asdf:

      asdf plugin add poetry
asdf install poetry latest
asdf global poetry latest

    • pipx:

      pipx install poetry

  2. Adicione ao PATH

    O instalador antigo usava a pasta $HOME/.poetry/bin. O novo usa a $HOME/.local/bin.

    Usando minha função no .zshrc:

    addToPathStart $HOME/.local/bin

  3. Instale as completions

    poetry completions zsh > ~/.zprezto/modules/completion/external/src/_poetry

    O comando acima é porque eu uso o Prezto. O importante é instalar em alguma pasta listada no $fpath.

  4. Crie um novo projeto

    poetry new meu-projeto
cd meu-projeto

  5. Defina a versão do Python usando o Pyenv ou asdf

    pyenv local 3.8.12

    ou

    asdf local 3.8.12

    $ nvim pyproject.toml
…
[tool.poetry.dependencies]
python = "^3.8"
…

    poetry env use -- /home/julio/.pyenv/versions/3.10.3/bin/python

    ou

    poetry env use -- /home/julio/.asdf/installs/python/3.10.3/bin/python

    poetry run python --version
poetry debug info

  6. Adicione as dependências

    Dependências de desenvolvimento são passadas com --dev.

    $ poetry add --group dev \
    bandit \
    black \
    codecov \
    coverage \
    flake8 \
    gitchangelog \
    isort \
    mkdocs \
    mypy \
    pydocstyle \
    pytest \
    pytest-cov

    poetry add typer\[all\]

  7. Atualize o Poetry

    poetry self update

    Lembre de gerar as completions novamente.

  8. Instale o poetry-plugin-up

    poetry self add poetry-plugin-up
poetry up --latest

    Este plugin atualiza os pacotes em pyproject.toml para a última versão.

Se o Poetry ficar preso “Resolving dependencies”, tente o seguinte:

find ~/.cache/pypoetry -name '*.lock' -type f -delete
poetry env remove --all
poetry cache clear --all .
rm -rf $(poetry config cache-dir)/artifacts

Mambaforge

Mambaforge combina Mamba e Conda-Forge.

O Mamba é uma reimplementação do gerenciador de pacotes Conda em C++. Ele resolve dependências bem rápido e faz downloads em paralelo.

O Canal Conda-Forge contém recipes escritas pela comunidade para o Conda. Ele possui muito mais pacotes do que o repositório oficial do Conda.

  1. Se você não quiser usar o Pyenv, é possível instalar o Mambaforge manualmente:

    wget https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-Linux-x86_64.sh
bash Mambaforge-Linux-x86_64.sh

  2. Atualize os pacotes base

    mamba update mamba
mamba update --all

  3. Crie e ative um ambiente virtual

    mamba create -n nome_do_env python=3.10 jupyterlab …
conda activate nome_do_env

  4. Instale alguns pacotes adicionais

    $ mamba install \
      azure-identity \
      bandit \
      black \
      bokeh \
      dask \
      flake8 \
      ipywidgets \
      isort \
      jupyterlab_code_formatter \
      kafka-python \
      keras \
      koalas \
      matplotlib \
      mypy \
      numpy \
      openpyxl \
      pandas \
      plotly \
      pyarrow \
      pycodestyle \
      pydocstyle \
      pylama \
      pylint \
      pyspark \
      pytest \
      python-graphviz \
      python-wget \
      scikit-learn \
      seaborn \
      sqlalchemy \
      tenacity \
      tensorflow \
      unidecode \
      xgboost

PDM

A PEP 582 foi rejeitada pelo Python Steering Concil em março de 2023.

Assim como o Poetry, o PDM é um gerenciador de pacotes e dependências.

A diferença é que ele segue as novas PEPs (PEP 582, PEP 517 e PEP 621).

É possível usar um virtualenv ou seguir a PEP 582 e usar uma pasta chamada __pypackages__. Essa pasta é equivalente à node_modules, ela é adicionada o sys.path.

Instalação

  • Via script:

    curl -sSL https://raw.githubusercontent.com/pdm-project/pdm/main/install-pdm.py | python3 -

  • Via asdf:

    asdf plugin add pdm
asdf install pdm latest
asdf local pdm latest

  • Completions no ZSH

    pdm completion zsh > ~/.zprezto/modules/completion/external/src/_pdm

Uso

  • Criar um projeto

    pdm init

  • Adicionar dependências

    pdm add requests flask

  • Adicionar dependências de desenvolvimento

    pdm add -dG dev jupyterlab jupyterlab-code-formatter black isort pylint mypy

  • Remover dependências

    pdm remove flask

  • Listar dependências

    pdm list --graph

  • Instalar projeto

    pdm install

  • Instalar baseado no arquivo .lock

    pdm sync

  • Atualizar dependências

    • Todos os pacotes

      pdm update

    • Um pacote específico

      pdm update <pacote>

      • Pacotes de um grupo

        pdm update -G <grupo>

      • Força atualização de pacotes pinados

        pdm update --update-eager

  • Remover pacotes não listados

    pdm sync --clean

  • Executar binário no ambiente

    pdm run jupyter lab

Atualização

pdm self update

Rust

O recomendado para desenvolver em Rust é utilizar o rustup, que pode ser instalado de duas formas:

  1. Script oficial:

    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

  2. Pacman:

    sudo pacman -S rustup
rustup default stable

    Essa forma é mais confortável no Arch, pois mantém o Rust e os pacotes que dependendem dele constantemente atualizados.

Teste a instalação:

$ rustc --version
rustc 1.53.0 (53cb7b09b 2021-06-17)

$ cargo --version
cargo 1.53.0 (4369396ce 2021-04-27)

$ rustdoc --version
rustdoc 1.53.0 (53cb7b09b 2021-06-17)

$ cargo new hello
 Created binary (application) `hello` package

$ cd hello

$ cargo run
   Compiling hello v0.1.0 (/home/julio/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/hello`
Hello, world!

Meu Neovim está configurado para usar o rust-analyzer como LSP Server. Basta instalar o binário:

sudo pacman -S rust-analyzer

Nvidia

Um dos notebooks possui uma GPU integrada da Intel e uma Nvidia GeForce RTX 2070 Max-Q, que possui melhor performance que a GPU Intel, porém consome mais energia.

É possível desligar uma das placas permanentemente ou utilizar a tecnologia Nvidia Optimus para alternar entre as placas de acordo com a necessidade.

Instale os drivers e utilitários:

sudo pacman -S nvidia nvidia-utils nvidia-settings opencl-nvidia

Executar um programa específico na Nvidia

Para fazer o chamado PRIME render offload basta inciar o programa com o comando prime-run. Ex.:

sudo pacman -S nvidia-prime
prime-run kdenlive

Usar apenas a placa Nvidia

sudo nvim /etc/X11/xorg.conf.d/10-nvidia-drm-outputclass.conf
Section "OutputClass"
    Identifier "intel"
    MatchDriver "i915"
    Driver "modesetting"
EndSection

Section "OutputClass"
    Identifier "nvidia"
    MatchDriver "nvidia-drm"
    Driver "nvidia"
    Option "AllowEmptyInitialConfiguration"
    Option "PrimaryGPU" "yes"
    ModulePath "/usr/lib/nvidia/xorg"
    ModulePath "/usr/lib/xorg/modules"
EndSection

$ nvim ~/.xinitrc (ou /usr/share/sddm/scripts/Xsetup para o SDDM)
xrandr --setprovideroutputsource modesetting NVIDIA-0
xrandr --auto
setxkbmap br -option caps:swapescape

Para garantir que o módulo será carregado antes da interface gráfica.

sudo nvim /etc/modprobe.d/nvidia-drm-nomodeset.conf
options nvidia-drm modeset=1

sudo nvim /etc/mkinitcpio.conf
MODULES=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)

sudo mkinitcpio -P

(Obs.: Se a partição /boot tiver pouco espaço livre, é possível desativar a geração da fallback image comentando as linhas relacionadas em /etc/mkinitcpio.d/linux.preset. Se isso não for suficiente, será necessário redimencionar as partições.)

sudo systemctl reboot

nvidia-smi

sudo pacman -S virtualgl
glxspheres64

Tearing

Screen tearing é quando partes de quadros diferentes são exibidos na tela ao mesmo tempo.

Esse problema era bem perceptível ao assistir vídeos no monitor conectado por HDMI. Teste com o vídeo https://youtu.be/MfL_JkcEFbE e com o site https://www.vsynctester.com.

  1. Configuração do Browser

    Verifique se ativar layers.acceleration.force-enabled no about:config do Firefox melhora alguma coisa.

  2. Force composition

    Essa opção pode aumentar a latência, porém foi o que resolveu meu problema.

    Verifique as configurações atuais:

    $ nvidia-settings --query CurrentMetaMode
  Attribute 'CurrentMetaMode' (Predator:0.0): id=50, switchable=yes, source=RandR :: DPY-2: nvidia-auto-select @1920x1080 +1920+0 {ViewPortIn=1920x1080, ViewPortOut=1920x1080+0+0}

    Ative o ForceCompositionPipeline (ou ForceFullCompositionPipeline):

    nvidia-settings --assign CurrentMetaMode="nvidia-auto-select +1920+0 { ForceCompositionPipeline = On }"

    O offset +1920+0 é porque a tela do notebook é full HD e fica à esquerda do monitor externo.

    Verifique as novas configurações:

    $ nvidia-settings --query CurrentMetaMode
  Attribute 'CurrentMetaMode' (Predator:0.0): id=50, switchable=no, source=nv-control :: DPY-2: nvidia-auto-select @1920x1080 +1920+0 {ViewPortIn=1920x1080, ViewPortOut=1920x1080+0+0,
  ForceCompositionPipeline=On}

    Adicione esse comando em um arquivo que é executado ao iniciar, como o autostart, xinit ou Xsetup.

    ~/bin/nvidia-force_comp_pipeline.sh:

    #!/bin/sh
s="$(nvidia-settings -q CurrentMetaMode -t)"
echo "$s"
if [[ "${s}" != "" ]]; then
  s="${s#*" :: "}"
  echo "$s"
  if [[ "${s}" != "NULL" ]]; then
    nvidia-settings -a CurrentMetaMode="${s//\}/, ForceCompositionPipeline=On\}}"
  fi
fi

    /usr/share/sddm/scripts/Xsetup:

    #!/bin/sh
# Xsetup - run as root before the login dialog appears

# Keyboards
kb_script="/home/julio/bin/keyboards.sh"
[ -s "$kb_script" ] && \. "$kb_script"

# Nvidia
xrandr --setprovideroutputsource modesetting NVIDIA-0
xrandr --auto

# Force Composition Pipeline
nfcp_script="/home/julio/bin/nvidia-force_comp_pipeline.sh"
[ -s "$nfcp_script" ] && \. "$nfcp_script"

    Se seus monitores são fixos, você pode usar o /etc/X11/xorg.conf.d/20-nvidia.conf:

    Section "Screen"
    …
    Option  "MetaModes" "nvidia-auto-select +0+0 {ForceFullCompositionPipeline=On}"
    …
EndSection

Window Managers e Desktop Environments

Awesome

Para o AwesomeWM, eu gosto das configurações do Gerome Matilla. Elas são um pouco bloated, mas os layouts são bem bonitos e possuem recursos interessantes.

KDE

O KDE Plasma é um DE muito bom com configurações padrões que me agradam bastante.

Eu evitava usar o KDE nos meus computadores antigos por ele não ser leve o bastante, porém com meus hardwares atuais isso não é mais um grande problema.

Recomendo instalar os seguintes pacotes:

sudo pacman -S ark \
        dolphin \
        gwenview \
        packagekit-qt5 \
        plasma-browser-integration \
        sddm \
        spectacle

A troca do Caps Lock pelo ESC pode ser feita em System Settings » Keyboard » Advanced » Caps Lock behavior » Swap Esc and Caps Lock.

Instale o kdeconnect no computador e em dispositivos Android para sincronizar notificações, compartilhar arquivos, compartilhar a área de transferência, usar o Android como mouse e teclado entre outras funções.

Teste as opções OpenGL e XRender em System Settings » Hardware » Display and Monitor » Compositor » Rendering backend. A melhor opção provavelmente é OpenGL, porém vi relatos de problemas com placas Nvidia.

Se não quiser mostrar os controles de mídia na tela de bloqueio, execute o seguinte comando:

kwriteconfig5 --file kscreenlockerrc --group Greeter --group LnF --group General --key showMediaControls --type bool false

Se as fontes estiverem muito grandes, force o DPI em System Settings » Fonts » Force font DPI: 96.

Tiling no KDE: Kröhnkite

  1. Mova a barra de tarefas para o topo da tela;

  2. Diminua o tamanho da barra (deixei em 30);

  3. Clique com o botão direito na barra de tarefas, clique em Show Alternatives e escolha “Icons-only Task Manager”;

  4. Botão direito sobre o Pager » Configure Pager

    • Show application icons on window outlines
    • Text display: Desktop number

  5. System Settings » Workspace » Window Management » KWin Scripts » Get New Scripts…

  6. Ative as configurações do Kröhnkite

    mkdir -p ~/.local/share/kservices5/
ln -s ~/.local/share/kwin/scripts/krohnkite/metadata.desktop ~/.local/share/kservices5/krohnkite.desktop

    Um botão configurar o Khrönkite aparecerá na tela KWin Scripts. Por lá eu faço o seguinte:

    • Ativação do Quarter layout
    • Gaps between tiles: 3 px
    • Prevent windows from minimizing
    • Remove borders of tiled windows

  7. System Settings » Appearance » Window Decorations » Edit Theme » Window-Specific Overrides » Add

    • Regular expression to match: .*
    • Border size: Tiny
    • Hide window title bar

  8. Entre em System Settings » Workspace » Workspace Behavior » Virtual Desktops e adicione quantos desktops você quiser (deixei 8, exibido em duas linhas);

  9. System Settings » Workspace » Workspace Behavior » Desktop Effects » Focus » Dim Inactive;

  10. System Settings » Workspace » Window Management » Window Behavior » Focus » Multiscreen behavior: Separate screen focus;

  11. Cor das bordas

    kwriteconfig5 --file ~/.config/kdeglobals --group WM --key frame 61,174,233
kwriteconfig5 --file ~/.config/kdeglobals --group WM --key inactiveFrame  239,240,241

  12. Remover tamanho mínimo das janelas

    • System Settings » Workspace » Window Management » Window Rules
    • Add New…
    • Window class: Unimportant
    • Window types: Normal Window
    • Add Properties…
    • Minimum Size: Force 0 x 0

  13. Troque os atalhos em System Settings » Workspace » Shortcuts » KRunner

    • KRunner: Meta + R

  14. Troque os atalhos em System Settings » Workspace » Shortcuts » KWin

    • Switch to Desktop n: Meta + n
    • Switch to Previous Screen: Meta + ,
    • Switch to Next Screen: Meta + .
    • Window to Desktop n: Meta+Shift+Fn (Usando Meta + F1,…,F8, porque Meta+Shift+6 não funciona com teclado US intl.)
    • Window to Previous Screen: Meta + <
    • Window to Next Screen: Meta + >
    • Krohnkite: Float All: Meta+Shift+F
    • Krohnkite: Right: Meta+L (use ctrl+alt+L para bloquear a tela)

Integração com Android

Dispositivos MTP só podem ser acessados por um programa.

Para sincronizar um tablet com o Calibre, o KDE não pode ter montado o dispositivo antes.

Mate o processo kiod5.

Gnome

O Gnome é um DE completo e bastante popular. Eu não gosto muito das configurações padrão, mas após alguns ajustes rápidos ele fica bem usável:

sudo pacman -S gnome gnome-tweaks gnome-shell-extension-appindicator evolution
sudo systemctl enable gdm
dconf write /org/gnome/desktop/input-sources/xkb-options "['caps:swapescape']"

Pelo Tweaks, ative a extensão app indicator e os botões de minimizar e maximizar.

Instale o Pipewire para o compartilhamento de tela funcionar no Waylaynd:

sudo pacman -S pipewire xdg-desktop-portal-gtk

Wine

  • Instale alguns dos seguintes pacotes (nem todos são necessários)
$ sudo pacman -S \
    wine-staging \
    wine-gecko \
    wine-mono \
    winetricks \
    zenity \
    playonlinux

$ sudo pacman -S \
    giflib \
    lib32-giflib \
    libpng \
    lib32-libpng \
    libldap \
    lib32-libldap \
    gnutls \
    lib32-gnutls \
    mpg123 \
    lib32-mpg123 \
    openal \
    lib32-openal \
    v4l-utils \
    lib32-v4l-utils \
    libpulse \
    lib32-libpulse \
    alsa-plugins \
    lib32-alsa-plugins \
    alsa-lib \
    lib32-alsa-lib \
    libjpeg-turbo \
    lib32-libjpeg-turbo \
    libxcomposite \
    lib32-libxcomposite \
    libxinerama \
    lib32-libxinerama \
    ncurses \
    lib32-ncurses \
    opencl-icd-loader \
    lib32-opencl-icd-loader \
    libxslt \
    lib32-libxslt \
    libva \
    lib32-libva \
    gtk3 \
    lib32-gtk3 \
    gst-plugins-base-libs \
    lib32-gst-plugins-base-libs \
    vulkan-icd-loader \
    lib32-vulkan-icd-loader \
    cups \
    samba \
    dosbox

  • Instale as fontes do Windows como explicado anteriormente

  • Rode o winetricks

    Com o zenity instalado, aparecerá uma GUI para ajudar a criar prefixos, instalar dependências, instalar e desinstalar programas.

    Os prefixos são criados em ~/.local/share/wineprefixes/.

  • Chame um programa pela linha de comando

    WINEPREFIX="~/.local/share/wineprefixes/nome_prefixo" wine ~/.local/share/wineprefixes/nome_prefixo/drive_c/Programa.exe

VPNs

A maioria das VPNs possui um instalador próprio (que muitas vezes já estará disponível no AUR).

Prefira WireGuard a OpenVPN quando possível.

Arch Linux
Julio Batista Silva
Julio Batista Silva
Engenheiro de Dados

Eu sou um engenheiro de computação apaixonado por ciência, tecnologia, fotografia e idiomas. Atualmente trabalhando como Engenheiro de Dados na Alemanha.

comments powered by Disqus