Aseprite. Opciones gratuitas y Compilación

Aseprite es un editor de imágenes propietario y de código fuente disponible, diseñado principalmente para dibujo y animación de Pixel Art.

Funciona en Windows , macOS y Linux , e incluye diferentes herramientas para la edición de imágenes y animaciones, como capas, marcos, compatibilidad con mapas de mosaicos (tiles), interfaz de línea de comandos y scripts Lua , entre otras.

Está desarrollado por Igara Studio SA y dirigido por los desarrolladores David, Gaspar y Martín Capello.
Aseprite se puede descargar como freeware que no permite guardar sprites, se puede comprar desde su pagina web o desde Steam o Itch.io.

El código fuente y los binarios de Aseprite se distribuyen bajo licencias EULA , educativas y propietarias de Steam .

Opciones gratuitas a Aseprite

El software es una maravilla a nivel profesional para la creación de imagenes de estilo Pixel Arrt o el diseño y creación de fondos, mapas o incluso animaciones.

Las opciones gratuitas son:

• Versión Trial: Puedes probarlo gratuitamente con su versión Trial, pero las opciones de grabación no estan activadas.
• LibreSprite: Es un fork (ramificación) de Aseprite. En Linux dispones unicamente de versión AppImage (v 1.1).
• Compilar Aseprite: Su licencia permite que descargues y compiles el codigo fuente para disponer de tu propia versión.

Opción 1: Aseprite versión Trial

Desde la página oficial de Aseprite, tienes la opción de descargar la opctión Trial: https://www.aseprite.org/trial/

Recuerda que es una versión completa en la que puedes realizar todas las opciones excepto Grabar.

Opción 2: LibreSprite

Tras la decisión de hacerlo software propietario, la comunidad hizo un fork del código oficial para crear una versión totalmente Gratuita y Open Source de Aseprite.

Disponen de versiones para Linux, Windows y recientemente para MacOS, la versión actual es la 1.1-dev todas las versiones están compiladas en modo Portable (Windows) ó AppImage (Linux).

En la versión de LibreSprite se ha modificado la ubicación de ciertas opciones del menú, respecto a la versión de Aseprite y actualmente no está disponible la posibilidad de cambiar el idioma de la aplicación.

Opción 3: Compilación de Aseprite

Si deseas usar las mismas opciones o versiones que existen para Aseprite, tienes la posibilidad de descargar y compilar tu mismo todo el código fuente de Aseprite y disponer de una versión completa y sin limitaciones.

En mi caso ha sido la opción que he elegido, pero te adelanto que no ha sido la más fácil...

Hasta disponer de una versión correcta que compilase he tardado casi unas tres horas, esto ha sido debido a varios factores: No hay mucha documentación para realizar una compilación completa, no hay muchos datos para la depuración de los errores de compilación según las dependencias de cada versión.

Despues de varias compilaciones con diferentes versiones, me he quedado con la versión 1.2.30

Para compilar en Debian, se necesita:

• Código fuente de aseprite (rama 1.2.30)
• Código fuente de herramientas depot-tools
• Código fuente de motor gráfico skia la versión para aseprite-m96
• Paquetes Debian: g++ cmake ninja-build libx11-dev libxcursor-dev libgl1-mesa-dev libfontconfig1-dev git libxi-dev python3

El resultado ha sido mi propia versión sin restricciones y perfectamente operativa de Aseprite v1.2.30:

La versión compilada admite incluir paquetes de idioma para el programa, con lo que se puede usar perfectamente en Español.
Actualmente estoy en proceso de la traducción al Español de España de todas las partes de la aplicación.
Sin embargo puedes ver que alguna de ellas ya aparecen traducidas...

El paquete compilado y funcionando lo he empaquetado en formato .deb, tanto para Debian 12 (Bookworm), como para Debian 13 (Trixie):

Package: aseprite
Version: 1.2.30
Architecture: amd64
Depends: libc6 (>= 2.27), libx11-6, libfreetype6, libfontconfig1
Maintainer: LuisGuLo <luisgulo@soloconlinux.org.es>
Priority: optional
Section: graphics
Filename: pool/main/a/aseprite/aseprite_1.2.30_amd64.deb
Size: 5870684
SHA256: 5c7fb1d946c985e087591764c29b30f3b4219ebbc97b2136afbf37017981c85b
SHA1: b9d0dcf704fb0fc4ee7393535fe7877b90301c12
MD5sum: 0e08aa6f49bcfa5be70f5e36591eb0d7
Description: Aseprite - pixel art tool. Compiled by SoloConLinux
 Aseprite is a pixel art editor with animation support, layers, and scripting.

Si teneis incluido en vuestro Debian el repositorio de SoloConLinux, podeis instalarlo directamente simplemente con el siguiente comando:

sudo apt update
sudo apt -y install aseprite

Detalle del proceso compilación

Si alquien quiere realizar su propia compilación os dejo el procedimiento que he tenido que seguir para que compilase sin problemas.
En mi caso la compilación la he realizado con un Debian GNU/Linux version 13 (Trixie)

• Paquetes Debian para la compilacion:
  Necesitamos disponer de varias aplicaciones para realizar la compilación sin problema, para ello los instalamos mediante:

sudo apt update
sudo apt -y install g++ cmake ninja-build libx11-dev libxcursor-dev libgl1-mesa-dev libfontconfig1-dev git libxi-dev python3

Vamos a realizar todo el trabajo de compilación en un directorio, por ejemplo ASEPRITE así que lo crearemos para poder descargar en él todo el código y herramientas necesarias:

# Crear Directorio de Trabajo
mkdir ~/ASEPRITE

# Nos cambiamos dentro...
cd ~/ASEPRITE

• Descargamos el código fuente del motor gráfico 2D Skia:

git clone -b aseprite-m96 https://github.com/aseprite/skia.git

La compilaciones con las ultimas versiones o incluso con la m102 me han dado fallos, así que opté por la versión m96 tras perder casi 2 horas depurando errores de librerías.
Este código ocupa la friolera de 6,2 Gb

• Herramientas y Wrappers de depot-tools

Descargamos el código fuente de las herramientas depot-tools necesarias para gestionar código y además de disponer de algunos wrappers de herramientas que se necesitan:

git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git

Luego necesitamos incluirlo en la ruta PATH en nuestra sesión actual, en la que trabajaremos:

export PATH="~/ASEPRITE/depot_tools:$PATH

Nota: Una vez exportado el PATH, continua en esa sesión para no tener problemas con los wrappers necesarios que se usan de depot_tools.

• Código fuente de Aseprite

Descargamos el código y usamos la rama 1.2.30 y corregiremos los submodulos:

# Clonar
git clone --recursive https://github.com/aseprite/aseprite.git

# Fijar rama deseada
cd aseprite
git checkout v1.2.30

# Corregir submodulos
git submodule sync
git submodule update --init --recursive

• Compilación de Skia

El procedimiento de compilación necesita del ajuste de algunos parámetros para que las librerias que generemos puedan funcionar en cualquier equipo incluso si no disponen de GPU y solo pueden usar CPU para los gráficos (-mno-avx).

Además quiero generar una única librería para poder generar al final una version estática de Aseprite y que funcione en cualquier Linux, sin tener que usar casi librerías, ya que las llevará enbebidas aunque ocupe un poco más.

El procedimiento es el siguiente:

# Compilar SKIA desde directorio skia
cd ~/ASEPRITE/skia

# Ajuste dependencias
python3 tools/git-sync-deps

# Preparar y Compilar
gn gen out/Release --args='is_official_build=true target_cpu="x64" extra_cflags=["-mno-avx"] skia_use_system_expat=false skia_use_system_libjpeg_turbo=false skia_use_system_libpng=false skia_use_system_libwebp=false skia_use_system_zlib=false'

ninja -C out/Release

• Ajuster previos para Aseprite

Para poder realizar el procedimiento de compilación, hay que realizar algunos pequeños ajustes previos para poder usar las librerias de Skia y poder generar el binario.

# Ajuste de librerias de terceros como modulos skcms
mkdir -p ~/ASPRITE/skia/modules/skcms/src
ln -s ~/ASPRITE/skia/include/third_party/skcms/skcms.h ~/ASPRITE/skia/modules/skcms/src/skcms_public.h

Corregir código Python:
Hay algun código de python con errores que hay que corregir antes de poder compilar sin errores.
Edita el fichero ~/ASEPRITE/skia/gn/is_clang.py y deja el código así:

#!/usr/bin/env python
#
# Copyright 2016 Google Inc.
#
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import subprocess
import sys
cc,cxx = sys.argv[1:3]

output = subprocess.check_output('%s --version' % cc, shell=True).decode('utf-8')
if ('clang' in output and
    'clang' in subprocess.check_output('%s --version' % cxx, shell=True)):
  print('true')
else:
  print('false')

Corregir includes

La versión de código C++ que se uso es anterior a alguna reglas actuales y hay includes que hay que ajustar para que compile correctamente, es necesario editar las dependencias de librerias/headers e incluir #include <cstdint> en donde se usen tipos uint8_t int8_t uint16_t int16_t uint32_t int32_t uint64_t int64_t

Comencé editando a mano los ficheros en los que me iba encontrando el error, pero al final, automaticé el parcheo de los ficheros mediante un script en bash.
Crea un fichero y llamalo parchear_cstdin.sh editalo e incluye el siguiente código:

#!/bin/bash
# SoloConLinux. Parchear errores cstdint
echo "Buscando headers que usan uint8_t sin incluir <cstdint>..."
# Ruta base del proyecto
BASE_DIR="~/ASEPRITE/aseprite"

# Tipos que requieren <cstdint>
TIPOS="uint8_t int8_t uint16_t int16_t uint32_t int32_t uint64_t int64_t"

# Buscar todos los .h y .hpp
find "$BASE_DIR" -type f \( -name "*.h" -o -name "*.hpp" \) | while read -r file; do
  # Verificar si el archivo usa alguno de los tipos
  if grep -qE "\b($TIPOS)\b" "$file"; then
    # Verifica si ya incluye <cstdint>
    if ! grep -q "#include <cstdint>" "$file"; then
      echo "Parcheando el código de : $file"
      # Añadimos la línea justo después del primer bloque de includes (mas facil de localizar)
      sed -i '/#include/ a #include <cstdint>' "$file"
    fi
  fi
done

echo "Parcheo 'cstdint' de Aseprite completo."

Dale permisos de ejecución y lanzaló para corregir el código en que se necesiten los includes:

# Permisos de ejecuion:
chmod +x parchear_cstdin.sh

# Lanzar para corregir
./parchear_cstdin.sh

Si queremos el ejecutable final salga nuestra propia versión deberemos de editar el fichero ~/ASEPRITE/aseprite/src/ver/CMakeLists.txt
En mi caso he dejado lo siguiente:

# ASEPRITE
# Copyright (C) 2020  Igara Studio S.A.

# Version of Aseprite
set(VERSION "1.2.30 SoloConLinux")

configure_file(
  "${CMAKE_CURRENT_SOURCE_DIR}/generated_version.h.in"
  "${CMAKE_CURRENT_BINARY_DIR}/generated_version.h")

# Custom Aseprite website (for testing server-side)
if(NOT "${CUSTOM_WEBSITE_URL}" STREQUAL "")
  add_definitions(-DCUSTOM_WEBSITE_URL="${CUSTOM_WEBSITE_URL}")
endif()

add_library(ver-lib info.c ${gen_ver_fn})
add_dependencies(ver-lib generated_version_h)
target_include_directories(ver-lib PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")

• Compilación de Aseprite

Y ahora si, ya podemos compilar, apuntando a las librerías de Skia.
Además indicamos que queremos generar un binario de tipo estático, para no tener que depender de librerías externas del sistema:

# Directorio para la  compilacion
cd ~/ASEPRITE/aseprite
mkdir build
cd build

# Preparamos compilacion con libskia y modo estático 
cmake -DCMAKE_BUILD_TYPE=Release \
      -DLAF_BACKEND=skia \
      -DSKIA_DIR=~/ASEPRITE/skia \
      -DSKIA_LIBRARY_DIR=~/ASEPRITE/skia/out/Release \
      -DSKIA_LIBRARY=~/ASEPRITE/skia/out/Release/libskia.a \
      -DENABLE_UI=ON \
      -DENABLE_STATIC=ON \
      -G Ninja ..

# Compilamos
ninja aseprite

Tras la compilación, veremos que hay un nuevo directorio bin dentro de la carpeta build y dentro tenemos nuestra versión compilada de aseprite simplemente nos podemos cambiar a este directorio y comprobar que funciona correctamente:

cd bin
./aseprite --version
Aseprite 1.2.30 SoloConLinux

Enhorabuena, ya tienes tu propia versión completa sin limitaciones de Aseprite v1.2.30