A Meta anunciou, durante o evento Meta Connect 2024, o lançamento do Llama 3.2, uma atualização dos seus modelos de inteligência artificial (IA) focada em dispositivos móveis e edge computing. Com uma abordagem aberta, essa nova versão oferece modelos compactos que podem ser executados diretamente em hardwares como Qualcomm, MediaTek e processadores Arm, proporcionando maior privacidade e eficiência para desenvolvedores.

O Llama 3.2 é composto por dois tipos principais de modelos: os de visão (11B e 90B) e os modelos de texto compactos (1B e 3B). Os modelos de visão foram criados para analisar imagens, gráficos e mapas, oferecendo uma interpretação visual dos dados e fornecendo respostas contextuais. Eles apresentam uma alternativa aberta a soluções proprietárias, como o Claude 3 Haiku, sendo ideais para tarefas como reconhecimento de imagens e geração automática de legendas.

Os modelos de texto, por sua vez, são otimizados para rodar localmente em dispositivos móveis. Com suporte para até 128 mil tokens, eles são indicados para funções como sumarização de mensagens, reescrita de textos e execução de comandos por instrução, tudo sem necessidade de conexão à nuvem, garantindo assim maior privacidade, já que os dados permanecem no próprio dispositivo.

Integração com plataformas parceiras

Além do lançamento do Llama 3.2, a Meta introduziu a primeira distribuição oficial do Llama Stack, um conjunto de ferramentas que simplifica o uso e a personalização dos modelos Llama em diferentes ambientes, sejam eles na nuvem, locais ou em dispositivos móveis. Em parceria com empresas como AWS, Databricks, Dell Technologies e Infosys, a Meta busca ampliar as aplicações comerciais e empresariais do Llama 3.2.

O Llama 3.2 também possui suporte imediato para plataformas como Microsoft Azure, Google Cloud, NVIDIA, Oracle Cloud e Intel, além de empresas de tecnologia de ponta que integram a solução diretamente em seus produtos.

Desempenho dos modelos

• Os modelos de visão do Llama 3.2 competem fortemente com outros grandes modelos, como Claude 3 Haiku e GPT4o-mini, em tarefas de reconhecimento e compreensão visual de imagens.
• O modelo de texto 3B superou concorrentes como o Gemma 2 (2.6B) e o Phi 3.5-mini em tarefas como seguir instruções, sumarização e reescrita de prompts, além de execução de comandos.
• O modelo de texto 1B mostrou-se competitivo com o Gemma em diversos benchmarks.

Esses resultados foram obtidos através de mais de 150 conjuntos de dados de benchmarks em várias línguas, com foco nas capacidades de compreensão visual e raciocínio dos modelos de visão LLMs.

Os modelos do Llama 3.2 já estão disponíveis para download no site oficial da Meta e no Hugging Face, com integração pronta para as plataformas dos parceiros. A Meta reforça que sua abordagem aberta é essencial para estimular a inovação, dando a desenvolvedores ao redor do mundo acesso a ferramentas poderosas e acessíveis para criar novas soluções com IA.

Hace tiempo, inspirado en una frase del gran Juan Febles «Con Linux si se puede» decidií hce un tiempo iniciar una serie de artículos donde presenté grandes aplicaciones que tiene el sistema GNU/Linux para realizar todas las tareas que necesitemos, sin tener nada o poco que envidiar a otras aplicaciones privativas. La segunda aplicación que presenté fue Zotero, un gestor de documentos de investigación. Hoy me complace compartir con vosotros que ha sido lazando Zotero 7, una nueva versión que destaca por un completo rediseño de la interfaz.

Lanzado Zotero 7, rediseñando el gestor de documentos

La noticia es de agosto pero por unas cosas o por otras no he podido compartirlo con vosotros. Mi gestor de documentos académicos ha recibido una gran actualización.

En palabras de sus desarrolladores:

Estamos encantados de anunciar el lanzamiento de Zotero 7, la mayor actualización en los 18 años de historia de Zotero y un gran salto adelante en diseño, rendimiento y funcionalidad.

Entre sus características nuevas nos encontramos:

• Un rediseño importante: Zotero 7 presenta un diseño bonito y moderno que seguirá resultando familiar a los usuarios de Zotero de toda la vida.
• Nuevo panel de elementos: se ha sustituido las pestañas horizontales (Información, Etiquetas, Notas, etc.) por secciones verticales plegables y una barra de navegación lateral para acceder rápidamente a secciones específicas.
• Nuevo modo oscuro, tanto para la aplicación como para los documentos pdf.
• Dos opciones de densidad para la interfaz de usuario de Zotero, Compacta y Cómoda.
• Más eficiencia dado que ahora es mucho más rápido en todos los ámbitos y ofrece compatibilidad nativa con los Mac de Apple, Windows de 64 bits y Windows en ARM, lo que garantiza un funcionamiento sin problemas en el hardware más reciente.
• Nueva versión del lector de PDF integrado, que, de hecho, ya no es sólo un lector de PDF.

Y muchos más, que me guardo para más adelante.

Más información: Zotero 7

¿Qué es Zotero?

Según la Wikipedia, Zotero es un gestor de referencias bibliográficas, libre (gratuito y de código abierto) desarrollado por el Center for History and New Media de la Universidad George Mason. Es un programa multiplataforma compatible con el sistema operativo GNU/Linux, Windows y Mac OS X y con los navegadores Chrome, Safari, Firefox y Edge

Las ventajas de Zotero respecto utilizar un simple documento de texto para tener recopilada esta información se puede resumir en:

• Organización mediante un sistema jerárquico de carpetas para diferentes proyectos o investigaciones.
• Utlización de plugins en los principales navegadores para automatizar tanto la descarga de documentos como la recopilación de los metadatos.
• Posibilidad de leer en la misma aplicación el documento en formato pdf y la realización de anotaciones en el mismo.
• Sincronización de toda la información generada y almacenada en Zotero en diversos dispositivos mediante los propios servidores de Zotero (de capacidad limitada) o en tu propio servidor (mediante Nextcloud, por ejemplo)
• Exportación de la bibliografía para trabajar estadísticamente en otras aplicaciones como RStudio.
• Creación de forma instantáneamente de referencias y bibliografías para cualquier editor de texto, y directamente dentro de Word, LibreOffice y Google Docs.
• Posibilidad de co-escribir un artículo con un colega, distribuir materiales de curso a los estudiantes, o construir una bibliografía colaborativa. Puedes compartir una biblioteca Zotero con tantas personas como quieras, sin coste alguno (esto no lo he probado)

Como vemos, se trata de una aplicación imprescindible para aquellos investgadores que quieran optimizar su trabajo y realizarlo de forma más eficiente.

Más información: Zotero

La entrada Lanzado Zotero 7, rediseñando el gestor de documentos se publicó primero en KDE Blog.

Last week I wrote about a campaign that we started to resolve issues on GitHub. Some of the fixes are coming from our enthusiastic community. Thanks to this, there is a new syslog-ng-devel port in MacPorts, where you can enable almost all syslog-ng features even for older MacOS versions and PowerPC hardware. Some of the freshly enabled modules include support for Kafka, GeoIP or OpenTelemetry. From this blog entry, you can learn how to install a legacy or an up-to-date syslog-ng version from MacPorts.

Read the rest of my blog at https://www.syslog-ng.com/community/b/blog/posts/huge-improvements-for-syslog-ng-in-macports

Last week I wrote about a campaign that we started to resolve issues on GitHub. Some of the fixes are coming from our enthusiastic community. Thanks to this, there is a new syslog-ng-devel port in MacPorts, where you can enable almost all syslog-ng features even for older MacOS versions and PowerPC hardware. Some of the freshly enabled modules include support for Kafka, GeoIP or OpenTelemetry. From this blog entry, you can learn how to install a legacy or an up-to-date syslog-ng version from MacPorts.

Read the rest of my blog at https://www.syslog-ng.com/community/b/blog/posts/huge-improvements-for-syslog-ng-in-macports

Veamos cómo configurar las contraseñas temporales de un solo uso (Time One Time Passwords) en nuestro gestor de contraseñas Pass en GNU/Linux

GitHub va a obligar a utilizar el doble factor de autentificación (2FA) a las personas que usen su plataforma y colaboren con código. De momento hay muchos repositorios de código de software libre que se encuentran en GitHub, la plataforma de repositorios git propiedad de Microsoft.

Existen alternativas más libres, comunitarias, pero todavía GitHub es el sitio donde reside mucho software con el que colaboro, por tanto voy a habilitar las contraseñas temporales de un solo uso (OTP) para poder seguir colaborando con esos proyectos hasta que se pasen a otros servicios.

Para utilizar las contraseñas utilizo pass el gestor de contraseñas de Unix, y para utilizar las contraseñas temporales de un solo uso (OTP) utilizaré pass con el complemento pass-otp.

Lo primero acceder a la página en cuestión, en este caso github y seguir los pasos para acceder a la habilitación del 2FA. Nos mostrará un código QR para escanear, aunque en mi caso, utilizaré «setup key» que nos mostrará un código o secreto.

Imaginemos que el código o secreto en cuestión es 112233AA5566TTBB9900, deberemos copiarlo porque lo vamos a utilizar más adelante para configurar pass.

Ahora en una terminal, vamos a añadir la opción de OTP a nuestra contraseña ya existente de github, para ello ejecuto lo siguiente:

pass otp append -e Web/github

Y nos pedirá que introduzcamos nuestro secreto:

Enter otpauth:// URI for Web/github.com:

Tendremos que escribir lo siguiente (con el secreto que hemos obtenido antes):

otpauth://totp/totp-secret?secret=112233AA5566TTBB9900

Aceptamos y ya tendremos configurada nuestra OTP para esta web. Ahora podemos probar que funciona bien, generando una OTP e introduciéndola en el campo de verificación de github. Para ello ejecutamos:

pass otp Web/github

Y nos generará un código similar a 772242 este será el código que introduzcamos en nuestra web cuando se solicite o en el campo de verificación del paso anterior en github.

Si todo ha salido bien, nos mostrará unos códigos de recuperación que tendríamos que guardar a buen recaudo.

También podemos guardarlos y gestionarlos con pass, ejecutando:

pass add -m Web/github_recovery_codes

Ahí iremos metiendo los códigos, cuando acabemos de introducirlos, pulsamos sobre Ctrl+D y ya hemos guardado los códigos para que los gestione y los guarde pass.

Si tenemos configurado pass para que guarde nuestras contraseñas en git, ahora deberíamos ejecutar pass git push y en otros dispositivos donde también utilicemos pass para sincronizar las nuevas contraseñas guardadas ejecutaremos pass git pull

Esto sirve para GitHub, pero también para otras webs que soliciten el 2FA con OTP.

Enlaces de interés

• https://victorhckinthefreeworld.com/2017/05/30/password-store-el-gestor-de-contrasenas-estandar-de-unix/
• https://victorhckinthefreeworld.com/2018/09/26/como-sincronizar-mediante-git-nuestras-contrasenas-de-pass/
• https://www.passwordstore.org/
• https://github.com/tadfisher/pass-otp
• https://docs.github.com/es/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication#configuring-two-factor-authentication-using-a-totp-app

Tras un parón debido al salto de Qt5/KF5 a Qt6/KF6 que realizó la Comunidad KDE el pasado 28 de febrero he decidido retomar esta sección aunque renonbrándola ya que en ella solo hablaré de Plasmoides para Plasma 6. De esta forma os presento un reloj analógico original llamado Mechanical Clock con el que ya llegamos al sexto plasmoides de la serie.

Reloj analógico original, Mechanical Clock – Plasmoides para Plasma 6 (6)

Como he comentado en otras ocasiones, de plasmoides tenemos de todo tipo funcionales, de configuración, de comportamiento, de decoración o, como no podía ser de otra forma, de información sobre nuestro sistema como puede ser el uso de disco duro, o de memoria RAM, la temperatura o la carga de uso de nuestras CPUs.

Así que espero que le deis la bienvenida a un plasmoide para plasma 6 escrito por un viejo conocido del blog ZayronXIO que recibe el nombre de Mechanical Clock, un reloj analógico muy original que mezcla la palabra clock con una esfera horaria clásica pero estilosa.

Y como siempre digo, si os gusta el plasmoide podéis «pagarlo» de muchas formas en la página de KDE Store, que estoy seguro que el desarrollador lo agradecerá: puntúale positivamente, hazle un comentario en la página o realiza una donación. Ayudar al desarrollo del Software Libre también se hace simplemente dando las gracias, ayuda mucho más de lo que os podéis imaginar, recordad la campaña I love Free Software Day de la Free Software Foundation donde se nos recordaba esta forma tan sencilla de colaborar con el gran proyecto del Software Libre y que en el blog dedicamos un artículo.

Más información: KDE Store

¿Qué son los plasmoides?

Para los no iniciados en el blog, quizás la palabra plasmoide le suene un poco rara pero no es mas que el nombre que reciben los widgets para el escritorio Plasma de KDE.

En otras palabras, los plasmoides no son más que pequeñas aplicaciones que puestas sobre el escritorio o sobre una de las barras de tareas del mismo aumentan las funcionalidades del mismo o simplemente lo decoran.

La entrada Reloj analógico original, Mechanical Clock – Plasmoides para Plasma 6 (6) se publicó primero en KDE Blog.

This article shows how to install and deploy Kubernetes (K8s) using RKE2 by SUSE Rancher on openSUSE Leap 15.6 with the NVIDIA GPU Operator. This operator deploys and loads any driver stack components required by CUDA on K8s Cluster nodes without touching the container host and makes sure, the correct driver stack is made available to driver containers. We use a driver container specifically build for openSUSE Leap 15.6 and SLE 15 SP6. GPU acceleration with CUDA is used in many AI applications. AI application workflows are frequently depoyed through K8s.

Introduction

NVIDIA's Compute Unified Device Architecture (CUDA) plays a crucial role in AI today. Only with the enormous compute power of state-of-the-art GPUs it is possible to process training and inferencing with an acceptable amount of resources and compute time.

Most AI workflows rely on containerized workloads deployed and managed by Kubernetes (K8s). To deploy the entire compute stack - including kernel modules - to a K8s cluster, NVIDIA has designed its GPU Operator, which, together with a set of containers, is able to perform this task without ever touching the container hosts.

Most of the components used by the GPU Operator are 'distribution agnostic' however, one container needs to be built specifically for the target distribution: the driver container. This is owed to the fact that drivers are loaded into the kernel space and therefore need to be built specifically for that kernel.

For a long time, NVIDIA kernel drivers were proprietary and closed source. More recently, NVIDIA has published a kernel driver that's entirely open source. This enables Linux distributions to publish pre-built drivers for their products. This allows for a much quicker installation. Also, prebuilt drivers are signed with the key thats used for the distribution kernel. This way, the driver will work seamlessly in systems with secure boot enabled. The container utilized below makes use of a pre-built driver.

In the next section we will explore how to deploy K8s on openSUSE Leap 15.6 once this is done, we will deploy the NVIDA GPU Operator in the following section run some initial tests. If you have K8s already running you may want to skip ahead to the 2nd part.

Install RKE2 on openSUSE Leap 15.6

We have chosen RKE2 from SUSE Rancher for K8s over the K8s packages shipped with openSUSE Leap: RKE2 is a well curated and maintained Kubernetes distribution which works right out of the box while openSUSE's K8s packages have been broken pretty much ever since openSUSE Kubic has been dropped.

RKE2 does not come as an RPM package. This seems strange at first, however, it is owed to the fact that Rancher wants to ensure maximal portability across various Linux distributions.

Instead, it comes as a tar-ball - which is not unusual for application layer software.

Most of what's described in this document has been taken from a great article by Alex Arnoldy on how to deploy NVIDIA's GPU Operator on RKE2 and SLE BCI. Unfortunately, it was no longer fully up-to-date and thus has been taken down.

Install the K8s server

Kubernetes consists of at least one server which serves as a control node for the entire cluster. Additionally clusters may have any number of agents - i.e. machines which workloads will be spread across. Servers will act as an agent as well. If your K8s cluster consists just of one machine, you will be done once your server is installed. You may skip the following section. For system requirements you may want to check here. We assume, you have a Leap 15.6 system installed already (minimal installation is sufficient and even preferred).

1. Make sure, you have all components installed already which are either required for installation or runtime:

   zypper -n install -y curl tar gawk iptables helm
   

   For the installation, a convenient installation script exists. This downloads the required components, performs a checksum verification and installs them. The installation is minimal. When RKE2 is started for the first time, it will install itself to /var/lib/rancher and /etc/rancher. Download the installation script:

   # cd /root
   # curl -o rke2.sh -fsSL https://get.rke2.io
   

2. and run it:

   sh rke2.sh
   

3. To make sure, that the binaries provided by RKE2 - most importantly, kubectl - are found and will find their config files, you may want to create a separate shell profile:

   #  cat > /etc/profile.d/rke2.sh << EOF
   export PATH=$PATH:/var/lib/rancher/rke2/bin
   export KUBECONFIG=/etc/rancher/rke2/rke2.yaml
   export CRI_CONFIG_FILE=/var/lib/rancher/rke2/agent/etc/crictl.yaml
   EOF
   

4. Now enable and start the rke2-server service:

   systemctl enable --now rke2-server
   

   With this, the installation is completed.
5. To check is all pods have come up properly and are running of have completed successfully, run:

   # kubectl get nodes -n kube-system
   

Install Agents

If you are running a single node cluster, you are done now and may skip this chapter. Otherwise, you will need to perform the steps below for every node you want to install as an agent.

1. As above, make sure, all required prerequisites are installed:

   # zypper -n install -y curl tar gawk iptables
   

2. Download the installation script

   # cd /root
   # curl -o rke2.sh -fsSL https://get.rke2.io
   

3. and run it:

   # INSTALL_RKE2_TYPE="agent" sh rke2.sh
   

4. Obtain the token from the server node, it can be found on the server at /var/lib/rancher/rke2/server/node-token. and add it to config file for the RK2 agent service:

   # mkdir -p /etc/rancher/rke2/
   # cat > /etc/rancher/rke2/config.yaml
   server: https://<server>:9345
   token <obtained token>
   

   (You have to replace by the name of IP of the RKE2 server host and by the agent token mentioned above.
5. Now you are able to start the agent:

   sytemctl enable --now rke2-agent
   

6. After a while you should see that the node is has been picked up by the server. Run:

   kubectl get nodes
   

   in the server machine. The output should look something like this:

   NAME     STATUS   ROLES                       AGE    VERSION
   node01   Ready    control-plane,etcd,master   12m   v1.30.4+rke2r1
   node02   Ready    <none>                      5m    v1.30.4+rke2r1
   

Deploying the GPU Operator

Now, with the K8s cluster (hopefully) running, you'd be ready to deploy the GPU operator. The following steps need to be performed on the server node only, regardless if this has a GPU installed or not. The correct driver will be installed on any node that has a GPU installed.

1. To simply configuration, create a file /root/build-variables.sh on the server node:

   # cat > /root/build-variables.sh <<"EOF"
   export LEAP_MAJ="15"
   export LEAP_MIN="6"
   export DRIVER_VERSION="575.57.08"
   export OPERATOR_VERSION="v25.3.2"
   export DRIVER_IMAGE=nvidia-driver-container
   export REGISTRY="registry.opensuse.org/network/cluster/containers/containers-${LEAP_MAJ}.${LEAP_MIN}"
   EOF
   

2. and source this file from the shell you run the following commands from:

   # source /root/build-variables.sh
   

   Note that in the script above we are using kernel driver version 555.42.06 for CUDA 12.5 instead of CUDA 12.6 as in 12.6 NVIDIA has introduced some dependency issues which have not been resolved fully, yet. This will limit CUDA used in the payload to 12.5 or older since a kernel driver version will only work for CUDA versions older or equal to the version it was provided with. This will be fixed in future versions so that later driver of GPU operator versions can be used. Also note, that $REGISTRY points to a driver container in https://build.opensuse.org/package/show/network:cluster:containers/nv-driver-container This is a driver container specifically built for Leap 15.6 and SLE 15 SP6. The nvidia-driver-ctr container will look for a container image ${REGISTRY}/${DRIVER_IMAGE} tagged: ${DRIVER_VERSION}-${ID}${VERSION_ID}. ${ID} and ${VERSION_ID} are taken from /etc/os-release on the container host. Currently, the container above is tagged for Leap 15.6 and SLE 15 SP6.
3. Add the NVIDIA Helm repository:

   # helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
   

4. and update it:

   # helm repo update
   

5. Now deploy the operator using the nvidia/gpu-operator Helm chart:

   # helm install -n gpu-operator \
     --generate-name   --wait \
     --create-namespace \
     --version=${OPERATOR_VERSION} \
     nvidia/gpu-operator \
     --set driver.repository=${REGISTRY} \
     --set driver.image=${DRIVER_IMAGE} \
     --set driver.version=${DRIVER_VERSION} \
     --set operator.defaultRuntime=containerd \
     --set toolkit.env[0].name=CONTAINERD_CONFIG \
     --set toolkit.env[0].value=/var/lib/rancher/rke2/agent/etc/containerd/config.toml \
     --set toolkit.env[1].name=CONTAINERD_SOCKET  \
     --set toolkit.env[1].value=/run/k3s/containerd/containerd.sock \
     --set toolkit.env[2].name=CONTAINERD_RUNTIME_CLASS \
     --set toolkit.env[2].value=nvidia \
     --set toolkit.env[3].name=CONTAINERD_SET_AS_DEFAULT \
     --set-string toolkit.env[3].value=true
   

   After a while, the command will return.
6. Now, you can view the additional pods that have started in the gpu-operator namespace:

   kubectl get pods --namespace gpu-operator
   

7. To verify that everything has been deployed correctly, run:

   # kubectl logs -n gpu-operator -l app=nvidia-operator-validator
   

   This should return a result like:

   Defaulted container "nvidia-operator-validator" out of: nvidia-operator-validator, driver-validation (init), toolkit-validation (init), cuda-validation (init), plugin-validation (init)
   all validations are successful
   

   Also, run:

    # kubectl logs -n gpu-operator -l app=nvidia-cuda-validator
   

   which should result in:

   Defaulted container "nvidia-cuda-validator" out of: nvidia-cuda-validator, cuda-validation (init)
   cuda workload validation is successful
   

   To obtain information on the NVIDIA hardware installed on each node, run:

   # kubectl exec -it "$(for EACH in \
     $(kubectl get pods -n gpu-operator \
     -l app=nvidia-driver-daemonset \
     -o jsonpath={.items..metadata.name}); \
     do echo ${EACH}; done)" -n gpu-operator -- nvidia-smi
   

One should note, that most arguments to helm install ... above are for the RKE2 variant of K8s. Some of them may be different for an 'upstream' Kubernetes or may not be needed at all for it.

With GNOME 47 out, it’s time for my bi-annual wallpaper deep dive. For many, these may seem like simple background images, but GNOME wallpapers are the visual anchors of the project, defining its aesthetic and identity. The signature blue wallpaper with its dark top bar remains a key part of that.

In this release, GNOME 47 doesn’t overhaul the default blue wallpaper. It's more of a subtle tweak than a full redesign. The familiar rounded triangles remain, but here’s something neat: the dark variant mimics real-world camera behavior. When it's darker, the camera’s aperture widens, creating a shallower depth of field. A small but nice touch for those who notice these things.

The real action this cycle, though, is in the supplemental wallpapers.

We haven’t had to remove much this time around, thanks to the JXL format keeping file sizes manageable. The focus has been on variety rather than cutting old designs. We aim to keep things fresh, though you might notice that photographic wallpapers are still missing (we’ll get to that eventually, promise.

In terms of fine tuning changes, the classic, Pixels has been updated to feature newer apps from GNOME Circle.

The dark variant of Pills also got some love with lighting and shading tweaks, including a subtle subsurface scattering effect.

As for the new wallpapers, there are a few cool additions this release. I collaborated with Dominik Baran to create a tube-map-inspired vector wallpaper, which I’m particularly into. There’s also Mollnar, a nod to Vera Molnar, using simple geometric shapes in SVG format.

Most of our wallpapers are still bitmaps, largely because our rendering tools don’t yet handle color banding well with vectors. For now, even designs that would work better as vectors—like mesh gradients—get converted to bitmaps.

We’ve introduced some new abstract designs as well -- meet Sheet and Swoosh. And for fans of pixel art, we’ve added LCD and its colorful sibling, LCD-rainbow. Both give off that retro screen vibe, even if the color gradient realism isn’t real-world accurate.

Lastly, there’s Symbolic Soup, which is, well... a bit chaotic. It might not be everyone’s cup of tea, but it definitely adds variety.

Preview

If you're wondering about the strange square aspect ratio, take a look at the wallpaper sizing guide in our GNOME Interface Guidelines.

Also worth noting is the fact that all of these wallpapers have been created by humans. While I've experimented with image generation for some parts of the workflow in some of of my personal projects, all this work is AIgen-free and explicitly credited.