Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/linuxdicaspro/archappimage

Empacotador de AppImage usando Conteiner Junest
https://github.com/linuxdicaspro/archappimage

appimage appimage-builder appimagetool archappimage archimage bwrap glibc junest proot

Last synced: 11 months ago
JSON representation

Empacotador de AppImage usando Conteiner Junest

Awesome Lists containing this project

README 

          


  




ArchAppImage





  Empacotador de AppImage Baseado no Projeto ArchImage que usa o

  Conteiner Junest para criar AppImage a partir de pacotes do Arch Linux.






## 📜 Descrição



O **`ArchAppImage`** facilita o empacotamento de programas no no formato **`AppImage`** 

usando pacotes do Arch Linux. Ele automatiza a criação de pacotes e melhora a

compatibilidade com o sistema, além de contar com vários métodos de criação de

AppImage e inclusão do **`GLibC`**.



Além disso, há outras formas disponiveis de fazer AppImage usando pacotes **`Debian`** com

inclusão do **`GLibC`**, e também empacotar programas autocontidos em  **`TarBall`**

para quem optar por AppImages mais leves, porém com uma menor garantia de funcionalidade,

por não incluir o **`GLibC`**.  

 ​   



![](https://upload.wikimedia.org/wikipedia/commons/thumb/a/a4/NVIDIA_logo.svg/330px-NVIDIA_logo.svg.png)



### Aceleração de HARDWARE para o Driver NVIDIA



```diff

- ---| SUPORTE EXPERIMENTAL |--- -

```



**Foi decidido não usar o projeto `Conty` para a detecção do driver da nvidia. Ao invés 

disso, foi usado um método simplificado e preciso para a detecção baseado em `POSIX`, que

para um AppImage faz mais sentido, já que a ideia é que o AppImage execute no máximo de

sistemas Linux possíveis. Além disso, é mais simples para manutenção.**  



## 🎯 Objetivo



O objetivo do **`ArchAppImage`** é oferecer uma solução simplificada para facilitar a

criação de **`AppImage`** em qualquer sistema usando vários métodos, principalmente via

contêiner, reduzindo a complexidade do processo e garantindo maior compatibilidade

entre vários sistemas Linux.



## 💡 Motivação



- O formato **`AppImage`** permite rodar aplicativos de forma portátil sem necessidade de

instalação. No entanto, a criação de AppImage pode ser trabalhosa. O método convencional

de empacotamento, pode exigir muitos testes em várias distros **`Linux`** para garantir o

máximo de compatibilidade possível. Portanto, é muito difícil garantir que o AppImage

vai funcionar na maioria das distros. 



- O método tradicional de criação de AppImage, sugere que você use um sistema mais

antigo para criar seus AppImages por conta do **`GLibC`**, o que faria com que fosse

necessário usar ou dedicar um ambiente **`oldstable`** separado do seu host ou uma VM

dedicada para a criação de Appimage.  



- Para cobrir o problema de compatibilidade com o **`GLibC`**, o mais recomendado é a

adição do próprio recurso ao AppImage, pois assim é possível usar o **`ld-linux`** para

abrir os programas.



- O projeto **`ArchImage`** é uma excelente ferramenta de criação de AppImage. Mas,

segundo meus testes, o desempenho e o modo como ele funcionava, não era satisfatório e

as vezes precisava esperar muito tempo ao repetir a criação do AppImage. Por isso,

eu decidi que eu queria uma solução extremamente rápida para criar AppImages sem precisar

esperar o AppImage empacotar de imediato para saber se o programa ia funcionar

perfeitamente após a criação do AppImage.



- A ideia de empacotar por **`Contêiner`** funciona bem, mas nem todos os programas

precisam ser empacotados dessa forma, então é necessário um modo de empacotamento que

criasse o AppImage, sem precisar de um contêiner para isso. 



- Soluções como **`bwrap`**, podem falhar em sistemas com restrições de **`namespaces`**

e não funcionarão. Uma solução é o **`proot`**, que é um pouco mais lento para iniciar

programas via conteiner, mas que é totalmente funcional. 



- Não é possível a execução do **`Junest`** usando superusuário. É preciso uma conta de

usuário comum para poder executar o AppImage. Distros modulares como o **`Puppy`**

costumam usar conta root por padrão, o que faz do AppImage baseado no Junest incompatível

com o sistema sem uma conta de usuário comum.



- Alguns programas podem precisar acessar o sistema **`host`** para poder realizar

alguma função no sistema. Eles podem acabar assumindo o contêiner como se fosse o host.



- Trabalhar com AppImage é uma forma de entender como o **`Sistema Linux`** funciona.



## ⛔️ Problemas do Método Tradicional de Criação de AppImage 



- Se o seu Sistema for muito desatualizado, você vai se deparar com um erro parecido

  com esse:

  ```bash

  /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.34' not found

  (required by /usr/lib/libstdc++.so.6)

  ```



- Não é possível garantir a adição de todas as dependências, uma vez que bibliotecas de

  baixo nível não costumam ser recomendadas para adição no AppImage.



- Ainda há programas que não foram pensados para serem portáteis e podem exigir acesso

  a caminhos absolutos em seus códigos.



- É difícil criar Appimages de programas desenvolvidos em **`Python`**.



## 🚀 Características e Recursos



- O Projeto conta com uma interface de linha de comando para a configuração mais básica.

Os ajustes mais refinados devem ser feitos normalmente no script de construção conforme

a necessidade.



- Várias opções de Scripts de Construção:



   - ✅ **`APP-ArchAppImage`** - usando contêiner junest.

   - ✅ **`APP-DebAppImage`** - cria AppImage usando contêiner debootstrap.

   - ✅ **`APP-Tarball2AppImage`** - cria AppImage com pacotes em tarball.



- São vários tipos de **`AppRun`** disponíveis:



   - ✅ **`AppRun_bwrap_proot`** - contêiner bwrap com proot como fallbak.

   - ✅ **`AppRun_default`** - modo padrão, sem contêiner.

   - ✅ **`AppRun_junest`** - contêiner junest.

   - ✅ **`AppRun_proot`** - contêiner proot.

   - ✅ **`AppRun_tarball`** - para AppImage em tarball.

   - ✅ **`AppRun_debian`** - modo padrão, sem contêiner, para AppImage usando Debian.



- Não há a necessidade de separar os projetos de **`AppImage`** em vários diretórios.

Pode ser usado o mesmo contêiner para empacotar vários AppImages diferentes,

economizando espaço em disco.



- Se for preciso, pode ser criado um conteiner só para uma aplicação específica da mesma 

forma que é feito no projeto do **`ArchImage`** e escolher se vai ser preciso uma dessas

opções para a construção do AppImage:



   - ✅ **`Mutilib`** - para programas que precisam de multilib.

   - ✅ **`ChaoticAUR`** - para programas do repositório do ChaoticAUR.

   - ✅ **`ArchLinuxCN`** - para programas do repositório do ArchLinuxCN.

   - ✅ **`AUR`** - para programas que serão compilados do repositório AUR.



- Possui resolução automática de dependências, podendo ser ajustado usando diferentes

níveis de busca por dependências.



- Em programas binários, pode ser habilitado uma busca por **`libs`**, que pode ajudar a

executar o programa usando menos níveis de busca por dependências, o que pode reduzir

o tamanho do AppImage.



- Você pode ativar a autointegração na área de trabalho e a autointegração de inicialização

durante a primeira execução do AppImage.



- Para o modo conteiner, foi implementado suporte ao driver **`NVidia`**. Ao ativar o

suporte, os drivers serão verificados toda vez que o AppImage for iniciado e atualizado

automaticamente conforme a necessidade. 



- Possui uma forma alternativa para configurar a detecção correta do idioma de forma

definitiva em caso de programas que não detectam o idioma de forma alguma.



- O método padrão conta com um método automático para resolver o cache do gdk-pixbuf2 para

ajudar na compatibilidade de programas que usam **`GTK`**.



## 🛠️ Instalação



Não há a necessidade de instalação, basta clonar o repositório e, se quiser, colocar em

algum local no sistema e linkar no **`/bin`** ou em algum local para ser adicionado na

variável **`PATH`**.



```bash

$ git clone https://github.com/LinuxDicasPro/ArchAppImage.git

$ cd ArchAppImage

$ sudo ln -s ArchAppImageGen /usr/bin/ArchAppImageGen

```



## 🖥️ Utilização Básica



1. A primeira coisa que você vai fazer, é abrir o utilitário via terminal:

   ```bash

   $ ArchAppImageGen

   ```

   Isso vai abrir uma ferramenta de configuração do script de construção do AppImage, que

   você pode configurar o local padrão do projeto pressionando **`C`** ou **`Enter`**

   para iniciar a configuração. Após a configuração, o script de construção será salvo

   no diretório padrão **`~/ArchAppImage`** ou no local que você configurou.



2. Depois você vai até o script gerado para a construção do AppImage no diretório do

   projeto que foi configurado, faça os ajustes e execute o script para criar o AppImage:

   ```bash

   $ cd ~/ArchAppImage

   $ kate package-ArchAppImage  # Faça os ajustes com o editor de sua preferência.

   $ ./package-ArchAppImage

   ```

   Se tudo der certo e o script estiver configurado corretamente, o AppImage será criado.



## ⚙️ Teste do AppImage



O **`RECOMENDADO`** é configurar o script para não criar o AppImage de imediato.

Assim, os testes serão feitos usando o AppRun. Entretanto, mesmo que o AppImage abra

corretamente, é sim necessário verificar seu funcionamento a procura de algum bug ou

alguma inconsistência. 



1. Execute o AppImage no terminal e verifique se não há nenhum erro durante a execução

   do programa:

   ```bash

   $ ./Sample-1.2.3-x86_64.AppImage

   ```



2. Para uma saída mais detalhada, use **`LD_DEBUG`**. Portanto, para procurar por

   **`libs`** faltantes, use:

   ```bash

   $ LD_DEBUG=libs ./Sample-1.2.3-x86_64.AppImage

   ```



3. Para ver os arquivos ausentes, use:

   ```bash

   $ LD_DEBUG=files ./Sample-1.2.3-x86_64.AppImage

   ```



   Para uma deparação mais aprimorada, consulte:  

   ​  ​  ​  ​ 🔹[The LD_DEBUG environment variable](https://www.bnikolic.co.uk/blog/linux-ld-debug.html)



## 📖 Documentação Completa



Para mais detalhes sobre o uso e as funcionalidades do **`ArchAppImage`**, projetos

incorporados e como solucionar problemas, consulte a documentação na wiki do github:



📜 [**Documentação Oficial do ArchAppImage**](https://github.com/LinuxDicasPro/ArchAppImage/wiki)



## 📷 Capturas de Tela





    

  

  




## 📝 Próximas Implementações



- 📌 **Empacotamento usando `sharun`.**

- 📌 **Reempacotador de AppImage para adição de modificações.**

- 📌 **Empacotamento usando flatpack.**

- 📌 **Futuramente, um Software de Desenvolvimento de AppImage em QT.**



## 🤝 Contribuindo



Contribuições são sempre **`Bem-Vindas!`** Se você deseja ajudar a melhorar este projeto,

siga as diretrizes abaixo para garantir um fluxo organizado e eficiente.



### 📌 Como contribuir



1. **Faça um fork do repositório**  

   - Clique no botão **`Fork`** para criar uma cópia do **`ArchAppImage`** na sua conta.



2. **Clone o repositório**  

   - No seu terminal, execute:

     ```bash

     git clone https://github.com//ArchAppImage.git

     cd ArchAppImage

     ```



3. **Crie um branch para sua modificação**  

   - Escolha um nome descritivo para o branch:

     ```bash

     git checkout -b my-contrib

     ```



4. **Faça as alterações e commit**  

   - Após editar os arquivos necessários, adicione suas mudanças:

     ```bash

     git add .

     git commit -m "description my contrib"

     ```



5. **Envie para o repositório remoto**  

   - Envie seu branch para o seu fork no GitHub:

     ```bash

     git push origin my-contrib

     ```



6. **Crie um Pull Request (PR)**  

   - Acesse o repositório original no GitHub e clique em **`New Pull Request`**.

   - Escolha o branch do seu fork e descreva suas alterações de forma clara.



### 📢 Dicas para um Pull Request bem-sucedido



- ✅ **Explique suas mudanças:** Escreva um título e uma descrição detalhada das alterações.  

- ✅ **Siga o padrão do código:** Mantenha a consistência do projeto.  

- ✅ **Faça commits pequenos e organizados:** Isso facilita a revisão.  

- ✅ **Revise seu código antes de enviar:** Evite bugs e erros desnecessários.  



Agradecemos sua contribuição! 🚀✨



## 📜 Licença



Este projeto é distribuído sob os termos da **`GNU General Public License version 3`**.  

Para mais detalhes sobre a licença, consulte o arquivo [**LICENSE**](LICENSE) ou acesse

o texto completo da licença no site da **`Free Software Foundation`**:



🔗 *https://www.gnu.org/licenses/gpl-3.0.html*



## ⚠️ Isenção de Responsabilidade



Este projeto tem como objetivo facilitar a criação de arquivos AppImage de forma prática

e acessível, inteiramente ao benefício da **`Comunidade`** e também para uso pessoal.

O autor não se responsabiliza por:



- ❌ Problemas em relação ao conteúdo, legalidade, qualidade, integridade ou segurança 

dos AppImages criados com esta ferramenta. O empacotador é quem deve garantir

a segurança e a integridade do AppImage.



- ❌ Qualquer violação de direitos autorais, licenças de software ou outras leis decorrentes

do uso da ferramenta. Softwares proprietários têm **`licenças restritivas`**. Geralmente,

você não terá o direito de redistribuir, modificar ou empacotar eles livremente, 

a menos que o dono permita.



  **OBS: Nesse caso, disponibilizar o script de criação para que o próprio usuário 

  crie o AppImage para uso pessoal pode ser uma opção.**



- ❌ Danos causados a sistemas operacionais, arquivos ou dispositivos devido ao uso de 

AppImages gerados por essa ferramenta, principalmente AppImage contendo código malicioso,

vulnerabilidades ou qualquer outro tipo de ameaça à segurança de sistemas.



- ❌ Qualquer outro uso que viole as leis locais, nacionais ou internacionais

decorrentes do uso da ferramenta.



O usuário é inteiramente responsável pelas ações que realizar utilizando esta ferramenta,

incluindo o que empacota, distribui e executa. Ao utilizar este projeto, você declara

estar ciente de sua responsabilidade e concorda em isentar o autor de qualquer

responsabilidade civil, criminal ou legal decorrente do mau uso dessa ferramenta.



### `IMPORTANTE:` 

- **Esta ferramenta é fornecida `no estado em que se encontra`, sem garantias explícitas

ou implícitas de qualquer tipo, incluindo garantias de funcionamento, segurança ou 

adequação a qualquer propósito específico, embora submetido a testes rigorosos.**

- **Esta ferramenta não é destinada à criação de AppImages de software proprietário

sem a devida autorização do proprietário ou entidade.**

- **Este aviso de isenção de responsabilidade não altera nem restringe as liberdades

garantidas pela licença GPLv3.**  



## 📩 Contato



- 📧 **Email**: *contatolinuxdicaspro@gmail.com*

- 💬 **Telegram:** [LinuxDicasPro](https://t.me/LinuxDicasPro)  

- ▶️ **YouTube:** [LinuxDicasPro](https://www.youtube.com/@LinuxDicasPro)  

- 👥 **Reddit:** [r/LinuxDicasPro](https://www.reddit.com/r/LinuxDicasPro/)