Tumbleweed es una distribución de GNU/Linux «Rolling Release» o de actualización contínua. Aquí puedes estar al tanto de las últimas novedades.

openSUSE Tumbleweed es la versión «rolling release» o de actualización continua de la distribución de GNU/Linux openSUSE.

Hagamos un repaso a las novedades que han llegado hasta los repositorios esta semana.

Y recuerda que puedes estar al tanto de las nuevas publicaciones de snapshots en esta web:

• https://victorhck.gitlab.io/tumbleweed_snapshots/

El anuncio original lo puedes leer en el blog de Dominique Leuenberger, publicado bajo licencia CC-by-sa, en este este enlace:

• https://dominique.leuenberger.net/blog/2024/01/opensuse-tumbleweed-review-of-the-week-2024-03/

En esta semana se han publicado 6 snapshots (0112, 0114…0118).

Los cambios más relevantes que han traído a los repositorios son:

• Linux kernel 6.6.11
• Pipewire 1.0.1
• Samba 4.19.4
• Mozilla Firefox 121.0.1
• Systemd 254.8
• KDE Frameworks 5.114.0
• ffmpeg 6.1.1
• Bash 5.2.26
• elfutils 0.190
• gnutls 3.8.3
• Wine 9.0

Y próximas actualizaciones traerán entre otros, estas actualizaciones en las que se están trabajando:

• RPM 4.19.1:
• rpm-config-SUSE
• Mesa 23.3.3
• Linux Kernel 6.7
• QEmu 8.2.0
• dbus-broker
• Ruby 3.3
• libxml 2.12.x
• openSSL 3.2.0

Si quieres estar a la última con software actualizado y probado utiliza openSUSE Tumbleweed la opción rolling release de la distribución de GNU/Linux openSUSE.

Mantente actualizado y ya sabes: Have a lot of fun!!

Enlaces de interés

• ¿Por qué deberías utilizar openSUSE Tumbleweed?
• zypper dup en Tumbleweed hace todo el trabajo al actualizar
• ¿Cual es el mejor comando para actualizar Tumbleweed?
• ¿Qué es el test openQA?
• http://download.opensuse.org/tumbleweed/iso/
• https://es.opensuse.org/Portal:Tumbleweed

——————————–

Dear Tumbleweed users and hackers,

As we can see in the number of larger and smaller things going through the staging process, the holiday season is over. To get all the changes out to the users, we have published six snapshots (0112, 0114…0118) this week.

The main changes delivered were:

• Linux kernel 6.6.11
• Pipewire 1.0.1
• Samba 4.19.4
• Mozilla Firefox 121.0.1
• Systemd 254.8
• KDE Frameworks 5.114.0
• ffmpeg 6.1.1
• Bash 5.2.26
• elfutils 0.190
• gnutls 3.8.3
• Wine 9.0

The staging projects currently show the community working on these changes:

• RPM 4.19.1: getting closer to be ready. packagers: please ensure to read/understand Ana’s announcement at https://lists.opensuse.org/archives/list/factory@lists.opensuse.org/thread/HG2JKUIKDTWQQIQSA43A4VWHX7YKJQT3/
• rpm-config-SUSE: enable full ksym() dependencies in Tumbleweed
• Mesa 23.3.3
• Linux Kernel 6.7
• QEmu 8.2.0
• dbus-broker: a big step forward; upgrades seem to be an issue that need to be addressed
• Ruby 3.3: all buld fails have been fixed/have a fix submitted. QA should happen next week.
• libxml 2.12.x: slow progress
• openSSL 3.2.0
• c-ares 1.21.0: nodejs build fails have been resolved, but a new cycle has formed: appstream-glib, c-ares, curl, googletest, nghttp2, python311

WebAssembly (abbreviated Wasm) is a portable binary instruction format. It has gained popularity for its portability as a compilation target that enables deployment on the web for both client and server applications.

We can leverage the portability of Wasm to run Wasm workloads alongside Linux containers by combining crun and Podman. crun supports running Wasm workload by using WasmEdge, Wasmtime, or Wasmer runtimes. While Podman defaults to runc, runc, and crun can be used interchangeably.

WasmEdge is a lightweight, high-performance, and extensible WebAssembly runtime for cloud-native and edge applications. WasmEdge was recently added to openSUSE Tumbleweed and this can give us support for Wasm workloads on containers if we enable an experimental feature in crun.

Now that we have WasmEdge in openSUSE Tumbleweed and crun experimental support for Wasm workloads we can run WebAssembly workloads on Podman. This new feature was introduced into Podman in Tumbleweed and also a new package. The blog post shows how to use it.

Preparing our environment

We first need to install crun as runc in the default OCI runtime for Podman.

zypper in crun

Once crun is installed check if you have Wasm support.

$ crun -v
crun version 1.9
commit: a538ac4ea1ff319bcfe2bf81cb5c6f687e2dc9d3
rundir: /run/user/1000/crun
spec: 1.0.0
+SYSTEMD +SELINUX +APPARMOR +CAP +SECCOMP +EBPF +CRIU +LIBKRUN +WASM:wasmedge +YAJL

In the above output, we can see that crun supports WasmEdge (+WASM:wasmedge).

Preparing our application

We are going to create a simple “Hello” application in Rust.

First, ensure you have Rust and WasmEdge installed.

zypper in rust wasmedge

Now let’s create our “Hello” application in Rust.

$ cargo new hello --bin
$ cd hello

Change the message in src/main.rs to Hello WebAssembly! or any other message you want.

Now let’s compile our application, but the target machine will be Wasm.

$ cargo build --target wasm32-wasi

We can now execute the binary we just compiled and check that it works as expected.

$ wasmedge run target/wasm32-wasi/debug/hello.wasm
Hello WebAssembly!

You have successfully built your Wasm application.

Creating a Wasm container

With our Wasm binary in hand, let’s add it to a container.

Create a file named Containerfile and add the following to it:

FROM scratch
COPY target/wasm32-wasi/debug/hello.wasm /
CMD ["/hello.wasm"]

Let’s build our Wasm container with Buildah.

$ buildah build --platform=wasi/wasm -t hello-wasm .

You should have a Wasm container by now.

Running a Wasm workload

Let’s run our Wasm container with Podman.

$ podman run --rm hello-wasm
Hello WebAssembly!

Great, we have a working Wasm container.

Conclusion

WebAssembly is a fairly recent topic, but it has gained a lot of attention because you can reuse most of what you already know or use and easily port applications.

Running a native Wasm container is another example of how portable this format is.

Results from a use case survey gave some insightful information about how people perceive openSUSE Slowroll.

Some view it as a replacement for openSUSE Leap, but recent news about a clear course set for Leap should help to explain that Slowroll has a different path.

Slowroll is an experimental distribution introduced in 2023. It was designed as a variant of openSUSE Tumbleweed when the future of openSUSE Leap was not yet clear.

The main characteristic of this distribution is a slower rolling release compared to Tumbleweed.

Some users might find value in this balance between rapid updates of Tumbleweed and a traditional stable release like openSUSE Leap. After all, the purpose and principles of open-source software is to promote software freedom, enable users to freely study, modify, and distribute software for any purpose; Slowroll is doing all of the above.

Slowroll integrates big updates every one month or so along with continuous bug fixes and security updates as they are available.

The idea behind Slowroll is to offer a distribution that improves stability without losing access to new features in the base packages such as the kernel, desktop environments and packaging. These slower update cycles allow for more extensive testing and validation of packages before their inclusion. Think of Slowroll as more of a skip than a Leap.

Regarding Slowrolls relationship with openSUSE Leap, it’s important to note that Slowroll is not a replacement for Leap. Rather, it provides an alternative for users seeking more up-to-date software at a slower pace than Tumbleweed, but much faster than Leap. This is particularly relevant in the context of the future branch of the SUSE Linux Enterprise distribution transitioning to ALP (Adaptive Linux Platform). The development of Slowroll originated from discussions among openSUSE developers about the future of the openSUSE Leap distribution, but has no other relation to the Leap release.

Slowroll is still rather new and is based on openSUSE Tumbleweed packages.

While Slowroll is a significant addition to the openSUSE family, it caters to users choosing a slightly slower up-to-date software system. The name Slowroll was chosen to reflect its slower update cycle and has been retained after a community voting process​.

Primer mes del año y otro mes que sigo la iniciativa #viernesdeescritorio con una nueva captura, con la que llegaré a más de dos años seguidos compartiendo «Mi escritorio» de forma mensual, una mirada a la intimidad de mi entorno de trabajo. De esta forma, bienvenidos a mi escritorio Plasma de enero 2024, el primero de un año que promete ser intenso en lo que se refiere a novedades kdeeras.

Mi escritorio Plasma de enero 2024 #viernesdeescritorio

Esta va a ser la cuadragésimocuarta (44 para los que nos cuesta leer esto) vez que muestro mi escritorio Plasma 5 en público, lo cual es número nada desdeñable de entradas que sigue creciendo de forma constante. Hice un recopilatorio con los 12 escritorios del 2022 y este diciembre he hecho una con los 13 del 2023. Por fin he encontrado el momento perfecto para hacer este tipo de entras.

Y sigo, tras unas entradas enseñando mi Slimbook Kymera AMD de sobremesa, realizando a captura está realizada sobre mi portátil Slimbook Pro de 13 pulgadas, el cual tiene instalado un KDE Neon con Plasma 5.27.10, sobre una versión de KDE Frameworks 5.113 y una versión de Qt 5.15.11. El servidor gráfico es Wayland y el Kernel es 6.2.0-39-generic (64 bits).

Respecto al tema general, sigo con el tema oscuro de Zayronxyo llamado Heimdall, con estilo de Plasma Frosted, colores y decoración de ventanas Deepin Dark e iconos Deepin 2022 Dark.

Respecto a plasmoides he puesto solo uno pero que me ofrece mucha información: Simple System Monitor. Si quieres más información te remito a la entrada de 29 de noviembre de 2019 donde ya hablé de él aunque en la captura ya se puede ver que ofrece mucha información del sistema.

Respecto al fondo, he de confesar que me he vuelto «adicto» a los fondos Neon y que me ha enamorado este de lynn23 que nos ofrece un entorno futurista, con colores saturados para que pueda resaltar la información del fondo.

El resultado de mi escritorio Plasma de enero de 2024 es un entorno de trabajo oscuro y, como siempre, funcional que podéis ver en la imagen inferior (pinchad sobre ella para verlo un poco más grande).

La entrada Mi escritorio Plasma de enero 2024 #viernesdeescritorio se publicó primero en KDE Blog.

This is report about a local denial of service vulnerability in the pam_namespace.so PAM module. This module is part of the core PAM modules that are found in the linux-pam project.

This report was previously shared with the linux-distros mailing list and is now published after linux-pam upstream released a new version 1.6.0 containing the bugfix on 2024-01-17.

Introduction

The pam_namespace module allows to setup “polyinstantiated directories” when setting up a user’s session during login. The typical example is setting up a private /tmp and/or /var/tmp for every user.

To achieve this a separate mount namespace is setup during login and a bind mount is performed in configured locations. Different methods are offered for this like a fixed per-user directory that is bind mounted (i.e. per-user contents are persistent and shared between sessions) or an ephemeral temporary directory (contents are lost after a session is closed).

The Vulnerability

The PAM module explicitly supports bind mounting of polyinstantiated directories in user controlled locations, like beneath the user’s home directory. Operating with root privileges in user controlled directories comes with a lot of dangers. To avoid them the function protect_dir() implements a special algorithm to protect the target path of a bind mount.

The function follows the target path for the bind mount starting from the file system root. Each path component that is under non-root control is protected from user manipulation, by bind mounting the path upon itself.

While this approach feels unusual, it should be effective to prevent any shenanigans on the side of the unprivileged user for whom the directory is mounted.

There is one bit missing though: The algorithm is not passing the O_DIRECTORY flag to openat() and is thus subject to special files like FIFOs being placed in user controlled directories. This can easily be reproduced e.g. using this configuration entry in the namespace.conf configuration file:

$HOME/tmp /var/tmp/tmp-inst/ user:create root

An unprivileged user (that is not yet in a corresponding mount namespace with ~/tmp mounted as a polyinstantiated dir) can now place a FIFO there:

nobody$ mkfifo $HOME/tmp

A subsequent attempt to login as this user with pam_namespace configured will cause the openat() in protect_dir() to block, causing a local denial of service.

The Bugfix

The bugfix I suggested fixes the issue by passing the O_DIRECTORY open flag to cause the open to fail if the path does not refer to a directory. With this some existing explicit checks of the file type can be dropped now.

Even with this patch applied the unprivileged user can still prevent the polyinstantiated directory from being mounted by placing a FIFO in the mount location. I don’t believe that pam_namespace gives (or should give) any guarantees in this regard, so I don’t consider it a problem.

Timeline

References

• linux-pam GitHub repository
• linux-pam v1.6.0 release containing the bugfix
• bugfix for the pam_namespace issue

Cada cierto tiempo me gusta hablar de Slimbook, la marca de dispositivos 100% compatibles con GNU/Linux por varias razones, entre las que destacan que soy usuario habitual de la marca y que tengo la convicción de que debemos promocionar las empresas que confían en el Sotware Libre. En la recta final del año pasado ya les dediqué tres artículos pero es que debería dedicarles más porque no paran. Es por ello que me complace compartir con vosotros que han sido lanzados los nuevos Executive de Slimbook, dentro de su serie de ultrabooks de alta gama ¿Tienes curiosidad? Sigue leyendo.

Nuevos Executive de Slimbook

Aunque en el mundo de las ordenadores de sobremesa o de escritorio la posibilidad de disfrutar de un sistema operativo libre es algo relativamente sencillo. De hecho, su conquista apenas tiene el problema del arranque y las tarjetas gráficas, el resto se soluciona rápido y bien (aunque las impresoras pueden ser un dolor de muelas).

No obstante siempre es de agradecer que algunas compañías como Slimbook se preocupen no solo de ofrecerte una alternativa que asegura su compatibilidad absoluta con los sistemas del GNU y el pingüino sino que te los afinen como solo los profesionales saben hacer (y si no me creéis os remito a este artículo donde un producto puesto a punto por los chicos y chicas de Slimbook barría en las pruebas de rendimiento a ordenadores en principio más potentes).

De esta forma me congratula compartir con todos vosotros que recientemente han presentado los nuevos ultrabooks Executive, una revisión de este modelo de alta gama que viene con su sello de calidad tradicional y con mejoras como:

• Memorias RAM DDR5 a 5200Mhz, en lugar de DDR4 3200Mhz.
• Procesador Intel® Core™ i7-13700H hasta 5,00 GHz, con 14 cores, 6 performance y 8 eficientes, que suman 20 hilos y caché de 24MB.
• Gráficos Intel® Iris® Xe G7 o NVIDIA® GeForce RTX™ 4060 de 8GB y TGP hasta 95W (siendo un 22% más potente que la anterior RTX 3060 de 4GB).
• Posibilidad de elegir color gris color o negro intenso.

Por cierto, y como suelo comentar en estos casos, esto tampoco es una entrada patrocinada. Mi relación con Slimbook es de cliente habitual, amistad e intereses mutuos (el dominio del mundo por parte de la filosofía GNU/Linux).

Más información: Slimbook

La entrada Nuevos Executive de Slimbook se publicó primero en KDE Blog.

Dear friends, comrades, partners in crime and moderate profit! I am pleased to announce the immediate availability of Chafa 1.14.0. There are release notes, but who's got time for that? All the fun stuff is in this post. You should be reading it instead.

Pixel perfection

Images can now be padded instead of stretched to fit their cell extent exactly –

– so I'll no longer have to explain why our 50kLOC monstrosity couldn't do pixel-perfect output, while sixcat (300LOC) did so effortlessly. Naturally, I had to make this as hard as possible for myself by splicing in padding before and after each row as they're processed for channel reordering and such, but on the plus side, this maximizes cache friendliness and parallelism behind a nice and homogeneous internal API.

You can get the old behavior back with --exact-size off. It defaults to auto, which will do the right thing (i.e. pad if image fits in viewport without scaling and scaling wasn't explicitly requested).

Another improvement in this vein is that sRGB is properly linearized in scaling operations now. This is pipelined along with everything else, and should be suitably fast.

Multiplexer passthrough

Previously, it was impossible to do better than character art inside multiplexers like tmux and GNU Screen. This is no longer the case; kitty has a new trick that allows for persistent raster image placement in these, which we implement. The above mentioned multiplexers have slight differences in their passthrough protocols; we support both with the new --passthrough argument.

We also support sixel passthrough. Sixels will be wrecked by multiplexer updates, so this is off by default. You can enable it with e.g. -f sixel --passthrough screen. tmux tends to dispose of the image immediately after we exit, so it may be a good idea to use --passthrough tmux -d 5 there so you get a chance to look at it first.

To my knowledge, Chafa is the only terminal graphics toolkit to offer passthrough for all four combinations of sixel/kitty and tmux/screen. I think the iTerm2 protocol would be doable too, if only.

MS Windows compatibility

It runs pretty well on Windows. You can use it in PowerShell. @oshaboy added support for ConHost, so it can technically be used on very old Windows versions – although this hasn't gotten much testing yet.

Python bindings

Erica Ferrua Edwardsdóttir's amazing Python bindings have been around for a while now, yet nary a peep from me on my blag. This shameful deficit stands in contrast to the stunning professionalism of her work. You need to do this:

pip install chafa.py

Do it now. Everything's well structured, the documentation is entertaining and well written, and there's even a tutorial. It's rare to see a project that simultaneously delivers and channels the spirit of F/OSS this well. You'll also find it on GitHub.

JavaScript enablement

Héctor Molinero Fernández started doing WebAssembly builds, which means you can now use the Chafa API from JavaScript. Like so:

npm install chafa-wasm

He also made a cool web app to show off all the bells and whistles!

Cheerleading aside, I've had no hand in either of these projects. The glory belongs to their respective maintainers, along with all of the praise, stars, code submissions ^{and issue reports, heh heh.}

Art!

@clort81 sent me this picture:

What's special about it? Well, it's character art!

You have to zoom in a bit before it becomes obvious; there're only two colors per character cell.

The glyphs are something else, though. You see, @clort81 wasn't happy with the limited offering of block drawing symbols in Unicode, and set out to create Blapinus, a 6125-glyph (!) hand-pixeled 6×12 PCF font with all the shapes you could ever want.

Plug that into your terminal (and Chafa), et voilà:

sudo cp blapinus.pcf.gz /usr/share/fonts/misc/
xterm -font -blap-*

Note that your fonts may live somewhere else, so relocate accordingly. Then inside XTerm, run:

chafa -f symbols --glyph-file blapinus.pcf.gz --symbols imported hello.png

If you see strange symbols in your output, you can try excluding some wide and ambiguous code points, e.g. --symbols imported-wide-ued00..uffff.

You can probably set this up in other terminals and display servers too, but know that it could be a long and winding path you're going down. Traveler beware. Or push the pedal to the metal and write a trip report. I'd love to read it.

If your terminal renders the font correctly, this can even have somewhat practical qualities:

First, it integrates perfectly with tmux and GNU Screen. Redraw, scrollback and editing just works, no passthrough tricks required.

Second, albeit lossy, the compression ratio is surprisingly good. Assuming four bytes per pixel, a 6×12 cell is 288 bytes uncompressed. We turn this into 39 bytes at most (a maximum of 36 bytes for the direct color sequence plus 3 bytes for the UTF-8 character), or an 86% reduction. Not bad, considering the compression dictionary is a 100kB font file.

Deflate will further compress this kind of data by 3/4, so if you're running this in a compressed ssh session, you can expect the total gain to be about 95%.

Prior art!

I've mentioned Mo Zhou's work before, but I'd be remiss not to bring it up here; they focused their considerable ML skills on a generator that takes a lot of the pain out of the font creation process. Just point it at an image collection, and by the magic of k-means clustering and a minimal increase in your carbon footprint, out pops a new font brimming with delectable puzzle pieces. You get scalable TTF, with SVG as an intermediate format, which is more agreeable with modern rendering stacks. Here it is in VTE:

This ML-generated font makes for a more organic look. There are unfortunately still some artifacts caused – presumably – by VTE's cell padding. The generator has offset hacks to work around it, but it's hard to make custom connective glyphs look perfect in every terminal.

You can read more about it in one of our longest-running GitHub issues. We're taking it all the way.

Cool applications

Chafa's found its way into the nooks and crannies of many a sweet application by now. I'd especially like to mention these three here:

ANSIWAVE BBS, the brainchild of Zach Oakes, is written in Nim and contains an embedded build of Chafa for character graphics generation. As a one-time (and sometimes) BBS sysop and denizen, this hits me right in the feels.

Felix is a nice file browser by Kyohei Uto written in Rust. It uses Chafa as an external image previewer.

kew, a terminal music player by the mysterious @ravachol, is written in C and uses the native Chafa API to generate cover previews. Development on this has been moving very quickly.

A laid-back place to chat about all this stuff

Issue trackers are formal and supposedly high-SNR. If you'd like a more relaxed place to chat about Chafa, your own programs, terminal graphics (modern or ancient), graphics programming in general or artistic expression related to any of these, drop by our secret business Matrix channel, #chafa:matrix.org. We'll be waiting.

I'm also enjoying Mastodon these days. Occasional announcements and amusements go there. It's good.

Thanks

Last, but not least: a big thank you to everyone who wrote code, reported bugs, filed suggestions and helped test this time around. And an extra big thanks to all the packagers and distributors who make the F/OSS world turn. You're the best.

Como decía en la anterior entrada de la serie estoy intentando huir de los plasmoides de Zayronxyo.. y por una vez lo he conseguido. Y es que he encontrado un widget que me ha hecho mucha gracia y que tiene su utilidad. Se llama Do not unplug yet y que hace jústamente eso, te avisa de que no desenchufes la memoria USB porque el sistema todavía está copiando archivos y podría estropearla.

No desenchufes la memoria USB, «Do not unplug yet» – Plasmoides de KDE (243)

Sigo con estas pequeñas aplicaciones que se conocen como applets, widgets o plasmoides y que dotan de funcionalidades de todo tipo a nuestro entorno de trabajo KDE y que parece que van a sufrir un lavado de cara considerable en Plasma 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.

En esta caso os presento un plasmoide de Luis Bocanegra que tiene de nombre «Do not unplug yet» y que, situado en la barra o directamente en tu fondo de pantalla, hace jústamente eso, te avisa de que no desenchufes la memoria USB porque el sistema todavía está copiando archivos y podría estropearla.

De esta forma, aparecerá un icono con el mensaje de advertencia cuando se transfieren archivos en segundo plano a unidades extraíbles. En palabras de ha creado este widget porque a veces parece que ya ha terminado de hacerlo pero en realidad no, ya queel sistema operativo utiliza la caché de escritura, que copia el archivo en la memoria ram (muy rápida) y luego en la unidad a una velocidad inferior.

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 No desenchufes la memoria USB, «Do not unplug yet» – Plasmoides de KDE (243) se publicó primero en KDE Blog.

Em uma iniciativa individual, estava decidindo qual tecnologia incluir no projeto JAX voltado para a criação musical. Durante a busca, avaliei várias opções como Muzic, MusicGen, stemgen, mustango, stableaudio, ultimatevocalremovergui, AudioLDM, musiclm-pytorch, dance-diffusion, Mubert-Text-to-Music, AIVA, Jukebox, magenta e audio-diffusion-pytorch. Nesse processo, descobri a plataforma SUNO, que começou a produzir músicas em português por volta de 29 de dezembro aproximadamente acho eu.

A criação da música levou cerca de 20 minutos, um processo acessível a qualquer pessoa, similar ao ChatGPT ou a geradores de imagens. É possível solicitar que a IA componha a música com base em um prompt ou fornecer versos e refrões específicos. Eu pedi uma música sobre pessoas tirando selfies no carnaval, com um ritmo pop carnavalesco. Segue abaixo o link com o resultado: https://distrokid.com/hyperfollow/jaxsuaia/carnaval-da-selfie

Abaixo o link das rádios onde a musica foi destaque:

• https://open.spotify.com/playlist/37i9dQZF1E4sAAL4UTCW33
• https://open.spotify.com/playlist/37i9dQZF1E4CU2UxdZIADr
• https://open.spotify.com/playlist/37i9dQZF1E4mYsPOMHq3AK
• https://open.spotify.com/playlist/37i9dQZF1E4ooRGfWtOa2A
• https://open.spotify.com/playlist/37i9dQZF1E4xWhB4r1fgLi
• https://open.spotify.com/playlist/37i9dQZF1E4lG1cyNGL6Mk
• https://open.spotify.com/playlist/37i9dQZF1E4rNOqTZ2jTSM
• https://open.spotify.com/playlist/37i9dQZF1E4t2U41orCEyT
• https://open.spotify.com/playlist/37i9dQZF1E4kGpcbubAz6a
• https://open.spotify.com/playlist/37i9dQZF1E4FwogHKHELkd
• https://open.spotify.com/playlist/37i9dQZF1E4rejAn0SyW5e