On September 24, PHP 8.5.11 fixed more than ten CVEs in OpenSSL, FPM, SOAP, Phar, and the HTTP stream wrapper, including a heap buffer overflow and a TLS hostname verification bypass. On October 21, PHP 8.5.12 went further: an emergency release for two critical vulnerabilities (CVE-2026-109618 and CVE-2026-109619, CVSS 9.2) that allow unauthenticated remote code execution. In php.net's own words, "updating is the only safe choice". The 8.4, 8.3, and 8.2 branches got the same fixes.

Here's the catch: Ubuntu 26.04 LTS (Resolute Raccoon) ships PHP 8.5 in its archive, but it freezes the version at release time and backports the fixes it considers important. At the time of writing, apt gives you PHP 8.5.4 with patches on top, while php.net is already at 8.5.12. To be fair, Ubuntu's security team handles the urgent stuff well: it shipped the October RCE fixes the same day as php.net. But the September batch took 25 days to land, and upstream's regular bug fixes rarely make it at all.

If you want the full upstream release, the easiest way is still to let the operating system handle it. Install PHP with apt from Ondřej Surý's repository, the same packages that have powered PHP on Debian and Ubuntu for more than a decade, and let sudo apt upgrade take care of the rest.

Support dates at a glance

Each PHP branch gets two years of active support followed by two years of security-only fixes. This is where things stand according to the official supported versions page:

If you're still on PHP 8.2, you have less than two months left. PHP 8.6 is scheduled for November 19, 2026, but PHP 8.5 is the safe bet to pair with an LTS distribution today. You can always try 8.6 side by side (see below).

On the OS side, Ubuntu 26.04 LTS was released in April 2026 and gets standard security maintenance until May 2031, extended to 2036 with Ubuntu Pro. So this setup will last for a while.

What's new in PHP 8.5

If you're coming from PHP 8.4 or older, here are a few reasons to upgrade beyond security. The release announcement has the full list, but my favorites are:

• The pipe operator, to chain callables from left to right without temporary variables.
• clone() with properties, which turns the "with-er" pattern for readonly classes into one line.
• The #[\NoDiscard] attribute, which warns when someone ignores a return value that matters.
• A native URI extension, with URL parsing that follows RFC 3986 and WHATWG, no more parse_url() surprises.
• array_first() and array_last(). Finally.

Here's the pipe operator turning a title into a slug:

$slug = $title
    |> trim(...)
    |> (fn (string $str): string => str_replace(' ', '-', $str))
    |> strtolower(...);

What changed: goodbye PPA, hello packages.sury.org

If you've installed PHP on Ubuntu before, you probably ran add-apt-repository ppa:ondrej/php. That's no longer the way to go: Ondřej Surý is moving his Ubuntu packages from Launchpad to packages.sury.org, the server that already hosts the Debian ones. The resolute packages for Ubuntu 26.04 are only published there.

If you still have the PPA configured, you may have seen apt update complain this summer that the repository changed its 'Label' value, an error that made apt-get update fail in scripts until you accepted the change. For now the PPA still gets updates for Ubuntu 22.04 and 24.04, but it's being merged into packages.sury.org. And if both are configured, apt keeps preferring the PPA builds, so remove it before following the steps below:

sudo add-apt-repository --remove ppa:ondrej/php

The new setup also improves how the signing key is handled. Instead of downloading a raw .gpg file, you install the official debsuryorg-archive-keyring package.

The easy way

As usual, you can install everything with a single command. The script adds the Sury repository, installs PHP 8.5 with the most common extensions, makes it the default php, and optionally installs Composer.

curl -fsSL https://angelblanco.dev/scripts/ubuntu-install-php-85.sh | bash

The script asks for confirmation at each major step. As always, read the script before you pipe it into bash. Trusting random URLs with sudo is a great way to learn about incident response.

If you don't have curl installed:

sudo apt update
sudo apt install curl

The step-by-step guide

Here's what the script does, in case you want to run it step by step.

1. Install the prerequisites

sudo apt update
sudo apt install -y ca-certificates curl unzip

PHP doesn't need unzip, but Composer uses it to extract packages much faster than its PHP fallback.

2. Install the Sury signing key

curl -fsSLo /tmp/debsuryorg-archive-keyring.deb https://packages.sury.org/debsuryorg-archive-keyring.deb \
  && sudo dpkg -i /tmp/debsuryorg-archive-keyring.deb \
  && rm /tmp/debsuryorg-archive-keyring.deb

This drops the key in /usr/share/keyrings/debsuryorg-archive-keyring.gpg (plus, for now, a global copy in /etc/apt/trusted.gpg.d/). On Debian the repository also ships the keyring package, so key rotations arrive with apt upgrade. The Ubuntu suites don't ship it yet, so if the key is ever rotated, download and install the .deb again.

3. Add the Sury repository

Since 24.04, Ubuntu uses the deb822 format (.sources files) for its own repositories, and the classic one-line .list format is now officially deprecated. The codename is read from /etc/os-release, so the same snippet also works on Ubuntu 22.04 and 24.04, and on derivatives like Linux Mint.

sudo tee /etc/apt/sources.list.d/php.sources > /dev/null <<EOF
Types: deb
URIs: https://packages.sury.org/php/
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: main
Architectures: $(dpkg --print-architecture)
Signed-By: /usr/share/keyrings/debsuryorg-archive-keyring.gpg
EOF

sudo apt update

4. Install PHP 8.5

sudo apt install -y php8.5-cli php8.5-mbstring php8.5-curl php8.5-zip php8.5-xml

Notice that we install php8.5-cli instead of the bare php8.5 metapackage. The metapackage pulls in Apache and its PHP module, which you probably don't want on your development machine. If you need a web server, add php8.5-fpm and pair it with Nginx or Caddy. Need a database? Add php8.5-mysql, php8.5-pgsql, or php8.5-sqlite3.

You don't need an apt pin: Sury's 8.5.12 has a higher version than Ubuntu's 8.5.4, so apt picks it automatically. You can check where each package comes from with:

apt policy php8.5-cli

5. Make PHP 8.5 the default

The php command is managed by update-alternatives, so you can choose which version answers to it:

sudo update-alternatives --set php /usr/bin/php8.5
php --version

6. Install Composer

The official installer publishes a SHA-384 checksum, so verify it before running anything:

EXPECTED_CHECKSUM="$(curl -fsSL https://composer.github.io/installer.sig)"
curl -fsSLo composer-setup.php https://getcomposer.org/installer
ACTUAL_CHECKSUM="$(php -r "echo hash_file('sha384', 'composer-setup.php');")"

if [ "$EXPECTED_CHECKSUM" = "$ACTUAL_CHECKSUM" ]; then
    php composer-setup.php --quiet
    sudo install -m 0755 composer.phar /usr/local/bin/composer
    rm composer.phar
    composer --version
else
    >&2 echo "ERROR: Invalid Composer installer checksum"
fi
rm composer-setup.php

Using install instead of mv makes root the owner of the binary, which matters because you'll run sudo composer self-update later.

What about other PHP versions?

This is where the Sury repository really shines. It publishes every branch from php5.6 to php8.5, plus the PHP 8.6 release candidates, and they can all live side by side:

sudo apt install -y php8.4-cli php8.4-mbstring php8.4-curl php8.4-zip php8.4-xml
sudo update-alternatives --config php

update-alternatives --config php shows an interactive menu to switch the default php. You can also call a specific version directly with php8.4 or php8.5, which is handy for running a legacy project's tests without touching your default.

If you try 8.6 before its final release on November 19, check apt policy php8.6-cli: builds older than RC4 don't include the October RCE fixes.

Keep in mind that every version you install is one more you have to keep patched. With Sury, at least, apt upgrade patches all of them at once.

The script

This is the complete script. It includes confirmations, uses a temporary directory that is removed on exit, and reads your answers from the terminal, so it works when you pipe it from curl. You can change the PHP version and the extensions with the variables at the top.

This script comes from my Neovim configuration repo, where I keep my install scripts. The editor needs php and composer for the PHP language servers and formatters to work, so I update them regularly. If you want the latest version, look there first.

#!/bin/bash
#
# Author: Ángel Blanco
# License: MIT
#
# This script is provided "as is", without warranty of any kind. Use at your own risk.
#
# Source: https://angelblanco.dev/blog/apt-install-php-85-on-ubuntu-26
#
# Usage:
#   curl -fsSL https://angelblanco.dev/scripts/ubuntu-install-php-85.sh | bash
#
# Install PHP (from packages.sury.org) and Composer on Ubuntu.
# Normally you will call it from your non-root user; elevated permissions
# will be granted with sudo.
#

set -euo pipefail

# You can configure these variables if needed
PHP_VERSION="8.5"
PHP_EXTENSIONS="cli mbstring curl zip xml"
KEYRING="/usr/share/keyrings/debsuryorg-archive-keyring.gpg"
SOURCE_FILE="/etc/apt/sources.list.d/php.sources"

# Basic confirmation module before executing the script.
confirm_action() {
    while true; do
        read -r -p "$1 (y/n): " choice < /dev/tty
        case "$choice" in
            [Yy]|[Yy][Ee][Ss]) return 0 ;;
            [Nn]|[Nn][Oo])     return 1 ;;
            *)                 echo "Invalid choice. Please enter 'y' or 'n'." ;;
        esac
    done
}

WORKDIR="$(mktemp -d)"
trap 'rm -rf "$WORKDIR"' EXIT

if ! confirm_action "Install PHP $PHP_VERSION from packages.sury.org?"; then
    echo "Skipping PHP installation. Exiting."
    exit 0
fi

# --- Prerequisites ---------------------------------------------------------
sudo apt update
sudo apt install -y ca-certificates curl unzip

# --- Sury signing key (official keyring package) ---------------------------
curl -fsSLo "$WORKDIR/debsuryorg-archive-keyring.deb" https://packages.sury.org/debsuryorg-archive-keyring.deb
sudo dpkg -i "$WORKDIR/debsuryorg-archive-keyring.deb"

# --- Sury repository --------------------------------------------------------
CODENAME="$(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")"

sudo tee "$SOURCE_FILE" > /dev/null <<EOF
Types: deb
URIs: https://packages.sury.org/php/
Suites: $CODENAME
Components: main
Architectures: $(dpkg --print-architecture)
Signed-By: $KEYRING
EOF

sudo apt update

# --- PHP --------------------------------------------------------------------
# Use -cli instead of the bare "phpX.Y" metapackage, which pulls in Apache.
PACKAGES=""
for EXTENSION in $PHP_EXTENSIONS; do
    PACKAGES="$PACKAGES php${PHP_VERSION}-${EXTENSION}"
done

# shellcheck disable=SC2086
sudo apt install -y $PACKAGES

sudo update-alternatives --set php "/usr/bin/php${PHP_VERSION}"

echo ""
php --version
echo ""

# --- Composer ---------------------------------------------------------------
if confirm_action "Install Composer?"; then
    cd "$WORKDIR"

    EXPECTED_CHECKSUM="$(curl -fsSL https://composer.github.io/installer.sig)"
    curl -fsSLo composer-setup.php https://getcomposer.org/installer
    ACTUAL_CHECKSUM="$(php -r "echo hash_file('sha384', 'composer-setup.php');")"

    if [ "$EXPECTED_CHECKSUM" != "$ACTUAL_CHECKSUM" ]; then
        >&2 echo "ERROR: Invalid Composer installer checksum"
        exit 1
    fi

    php composer-setup.php --quiet
    sudo install -m 0755 composer.phar /usr/local/bin/composer

    echo ""
    composer --version
fi

echo ""
echo "Installation process finished."
echo "Run 'sudo apt update && sudo apt upgrade' periodically to get PHP security releases."

Keep everything up to date

Once it's installed, keeping it up to date takes just a couple of commands:

# Operating system and PHP
sudo apt update && sudo apt upgrade

# Composer
sudo composer self-update

Even on 8.5.12, php.net recommends disabling session upload progress until the next release, to fully close an unlikely RCE path (CVE-2026-115560). If you serve PHP with FPM, it's a one-liner:

echo 'session.upload_progress.enabled=0' | sudo tee /etc/php/8.5/fpm/conf.d/99-session-upload-progress.ini
sudo systemctl restart php8.5-fpm

And don't forget your project dependencies: composer outdated and composer audit tell you what needs updating and which packages have known vulnerabilities.

Two rounds of PHP security releases in less than a month, one of them an emergency, is a good reminder that you can't predict which patch will matter. What you can do is make applying them boring: one apt upgrade for PHP, one composer self-update for Composer, and composer audit for your projects. Set it up once and stop thinking about it.

Keeping Node.js up to date isn't optional: it's worth spending some time on it, both on your personal computer and on your server. The easiest way is to let the operating system handle those updates for you. To do that, install Node.js with apt from the NodeSource repository and let sudo apt upgrade take care of the rest.

Now that Node.js 26 (Lithium) has been LTS since October 28, 2026 and Ubuntu 26.04 LTS (Resolute Raccoon) has been out for months, it's a good time to get it properly installed. The recipe is the same as in my Node.js 24 on Ubuntu 24 guide.

Support dates at a glance

Both releases have long support windows, so this setup will last for a while:

Node.js 26 moves to maintenance on October 20, 2027 (see the official release schedule), and it's the last release under the odd/even model: from Node.js 27 onwards, the project ships one major release per year and every release becomes LTS. If you're still on Node.js 24, don't panic: it's supported until April 2028 (and Node.js 22 until April 2027).

What changed since Node.js 24

Most of the steps are the same, but there is one important change: Corepack is no longer bundled with Node.js. It was removed in Node.js 25, so corepack enable doesn't work on a fresh Node.js 26 install. The Node.js docs point to the userland corepack package if you still want it.

I took the simplest route and now install pnpm with its own standalone installer. If you use Yarn, you can install the corepack package globally (see below).

The easy way

As before, you can install everything with a single command. The script installs Node.js 26 from NodeSource, configures a global npm prefix (so you don't need sudo for global packages), and can optionally install pnpm and Bun.

curl -fsSL https://angelblanco.dev/scripts/ubuntu-install-node-26.sh | bash

The script asks for confirmation at each major step. As always, read the script before you pipe it into bash. Running random scripts from the internet is a fun hobby until it isn't.

If you don't have curl installed:

sudo apt update
sudo apt install curl

The step-by-step guide

Here's what the script does, in case you want to run it step by step.

1. Update dependencies and add the NodeSource repository

First, install the tools needed to download and verify packages:

sudo apt update
sudo apt install -y ca-certificates curl gnupg

Then add the NodeSource repository for Node.js 26:

curl -fsSL https://deb.nodesource.com/setup_26.x | sudo -E bash -

NodeSource uses a single nodistro suite for every Debian-based distribution, so it works on Ubuntu 26.04 without waiting for a codename-specific repository. The setup script also adds an apt pin with priority 600, so the NodeSource package always wins over the nodejs package from the Ubuntu archive. Without it, you could end up with an older Node.js from the Ubuntu repositories.

2. Install Node.js and npm

sudo apt-get install -y nodejs
node --version

This installs both the node runtime and npm.

3. Configure npm's global prefix

To install global packages without sudo, set up a directory in your home folder:

mkdir -p ~/.npm-global
npm config set prefix '~/.npm-global'

Then add it to your PATH in ~/.bashrc or ~/.zshrc:

export PATH=~/.npm-global/bin:$PATH

4. Install pnpm

Since Corepack is no longer included, install pnpm with its standalone script:

curl -fsSL https://get.pnpm.io/install.sh | sh -

The installer adds pnpm to your PATH in your shell config, so open a new terminal (or source your config file) before you run pnpm --version. From then on, pnpm self-update keeps it up to date.

5. Install Bun (optional)

If you want to try Bun, use its official installer, which needs unzip:

sudo apt install -y unzip
curl -fsSL https://bun.sh/install | bash

What about Yarn?

If your projects use Yarn, you can still use Corepack. You just need to install it yourself:

npm install -g corepack
corepack enable

Because we configured a global npm prefix, this works without sudo. Keep in mind that the Corepack package is now maintained outside the Node.js release cycle, so check its README if something behaves unexpectedly on Node.js 26.

The script

This is the complete script. It includes confirmations, uses a temporary directory that is removed on exit, and reads your answers from the terminal, so it works when you pipe it from curl.

This script comes from my Neovim configuration repo, where I keep my install scripts. The editor needs Node.js for several language servers and plugins, so I update them regularly. If you want the latest version, look there first.

#!/bin/bash
#
# Author: Ángel Blanco
# License: MIT
#
# This script is provided "as is", without warranty of any kind. Use at your own risk.
#
# Source: https://angelblanco.dev/blog/apt-install-node-26-on-ubuntu-26
#
# Usage:
#   curl -fsSL https://angelblanco.dev/scripts/ubuntu-install-node-26.sh | bash
#
# This script installs Node.js and several package managers.
# Run it as your non-root user: it asks for elevated permissions
# with sudo when needed.
#

set -e

# Basic confirmation module before executing the script.
confirm_action() {
    read -p "$1 (y/n): " choice < /dev/tty
    case "$choice" in
        [Yy]|[Yy][Ee][Ss])
            return 0
            ;;
        [Nn]|[Nn][Oo])
            return 1
            ;;
        *)
            echo "Invalid choice. Please enter 'y' or 'n'."
            confirm_action "$1"
            ;;
    esac
}

# You can configure these variables if needed
NODE_VERSION=26
NPM_PREFIX="~/.npm-global"
DEPS="ca-certificates curl gnupg"

TMP_DIR=$(mktemp -d)
trap 'rm -rf "$TMP_DIR"' EXIT

echo "This script will install Node.js and optionally other package managers."
echo ""

if ! confirm_action "Install Node.js version $NODE_VERSION?"; then
    echo "Skipping Node.js installation. Exiting."
    exit 0
fi

echo "Installing the dependencies needed to install Node.js..."

sudo apt update
sudo apt install -y $DEPS

echo "Installing Node.js..."
curl -fsSL https://deb.nodesource.com/setup_$NODE_VERSION.x -o $TMP_DIR/nodesource_setup.sh
sudo -E bash $TMP_DIR/nodesource_setup.sh

sudo apt-get install -y nodejs

mkdir -p ~/.npm-global
npm config set prefix $NPM_PREFIX
echo "npm prefix set to $NPM_PREFIX"

echo "Node.js installation completed."
echo "Node version: "
node --version

echo ""

if confirm_action "Install pnpm?"; then
    echo "Installing pnpm..."
    curl -fsSL https://get.pnpm.io/install.sh | sh -
    echo "pnpm installation completed. Open a new terminal (or source your shell config) to use it."
fi

echo ""

if confirm_action "Install Bun?"; then
    echo "Installing Bun..."
    sudo apt install -y unzip
    curl -fsSL https://bun.sh/install | bash
    export BUN_INSTALL="$HOME/.bun"
    export PATH="$BUN_INSTALL/bin:$PATH"
    echo "Bun version: "
    bun --version
fi

echo ""
echo "Installation process finished."
echo ""
echo "Add the global npm bin directory to your PATH by adding this line to your .bashrc or .zshrc:"
echo 'export PATH=~/.npm-global/bin:$PATH'
echo ""
echo "Node.js now comes from apt, so keep it patched with:"
echo "sudo apt update && sudo apt upgrade"
echo ""

Keep everything up to date

Once it's installed, keeping it up to date takes just a couple of commands:

# Operating system and Node.js
sudo apt update && sudo apt upgrade

# Package managers
pnpm self-update
bun upgrade
npm update -g

And don't forget your project dependencies: pnpm outdated and pnpm audit tell you what needs updating.

That's also why I still don't use NVM day to day, as I explained in the previous post. It's great if you really need several Node.js versions side by side, but every version you install with NVM is one more you have to remember to patch.

With AI speeding up how fast vulnerabilities are found and exploited, and security breaches that keep popping up, staying up to date has to be as easy as possible. Because now, more than ever, it's not optional.

Why I love antfu/eslint-config

Discovering @antfu/eslint-config changed how I configure ESLint. The move to "Flat Config" seemed unnecessary to me, until Anthony Fu built a config that makes ESLint simple to set up and extend.

Instead of juggling dozens of plugins, configurations and dependencies, you install one package and you're done. It's zero config by default: you import it, export it, and it respects your .gitignore. It looks at your project and enables the right rules for Vue, TypeScript or plain JavaScript, with opinionated defaults you can override.

It also formats your code, so for most projects you don't need Prettier. Besides JavaScript and TypeScript, it handles JSON, Markdown and YAML, so ESLint manages everything.

For my usual stack (Vue and TypeScript), it's the best starting point for configuring ESLint.

Why create your own ESLint config package?

Extending antfu's config with my own preferences and plugins is simple, since it's designed for composing your own configuration. I'm used to ending lines with semicolons, indenting with 2 spaces and putting the <template> at the top of my .vue files.

But the real value isn't personal taste. It's consistency and reuse. Once you publish your ESLint config as an npm package, you can:

• Add plugins for specific libraries that can't be part of antfu's core.
• Use it in all your repositories, with the same rules everywhere.
• Version your linting rules: update the package, bump it in your projects, and they all get the new rules.
• Share it with your team or make it public.
• Maintain it in one place instead of updating the same rules in 10 projects.

My config: @angelblanco/eslint-config

My configuration, @angelblanco/eslint-config, is available on npm, and the source code is on GitHub:

github.com/angelblanco/eslint-config · Ángel Blanco's ESLint configuration, built on @antfu/eslint-config for Vue + TypeScript projects.

How to create your own

Creating your own ESLint config is straightforward. Instead of starting from scratch, you can fork mine:

1. Fork @angelblanco/eslint-config.
2. Register on npm with your GitHub username.
3. Update package.json with your own package name, for example @yourname/eslint-config, and the rest of the details.
4. Install the dependencies with pnpm install.
5. Customize the rules in index.ts.
6. Build the JavaScript output with tsup by running pnpm build.
7. Publish it with npm publish --access public.
8. Install @yourname/eslint-config in your other repositories and import it in their ESLint config.

The README in my repository has up-to-date installation instructions, usage examples and every rule I changed. Open an issue if you want a hand.

Make it yours

You don't need to reinvent the wheel. Start from something solid like @antfu/eslint-config, adjust it to your taste and publish it. The whole process takes about an hour, and you end up with one versioned linting configuration for all your projects.

If you work with Vue and TypeScript, try antfu's config or mine. If neither is exactly what you want, fork it and make it yours.

We'll cover a one-liner script that automates everything, including setting up a proper global prefix for npm and enabling Yarn and pnpm via Corepack. For those who prefer manual control, we'll also walk through each step in detail.

The easy way

I've created a script, so you can install everything by running a single command. This script will set up Node.js 24, configure a global npm prefix (so you don't need sudo for global packages), and optionally enable corepack (for Yarn and pnpm) and install Bun.

Just open your terminal and run this:

curl -fsSL https://angelblanco.dev/scripts/ubuntu-install-node-24.sh | bash

The script will ask for confirmation at each major step, so you still have control over what gets installed. You can also review the full script content before running it or customize it for your own needs.

If you don't have curl installed:

sudo apt update
sudo apt install curl

The step-by-step guide

For those who prefer a hands-on approach, here’s a breakdown of what the script does. You can follow these steps to perform the installation manually.

1. Update dependencies and add the NodeSource repository

First, we need to make sure our system has the necessary tools to fetch and install Node.js.

sudo apt update
sudo apt install -y ca-certificates curl gnupg

Next, we'll add the NodeSource repository, which is a trusted source for up-to-date Node.js versions on Debian and Ubuntu.

curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -

2. Install Node.js and npm

With the repository in place, installing Node.js is as simple as running:

sudo apt-get install -y nodejs

This command installs both the node runtime and the npm package manager.

3. Configure npm's global prefix

By default, npm installs global packages in a system directory that requires sudo. This can lead to permission issues down the line. To avoid this, it's a best practice to configure a local directory for your global packages.

mkdir -p ~/.npm-global
npm config set prefix '~/.npm-global'

You'll also need to add this directory to your PATH. Open your ~/.bashrc or ~/.zshrc file and add the following line:

export PATH=~/.npm-global/bin:$PATH

4. Enable Corepack (for Yarn and pnpm)

Corepack is an experimental tool included with Node.js that simplifies managing different package managers. With it, you don't need to install Yarn or pnpm manually.

To enable it, just run:

sudo corepack enable

Now you can use yarn and pnpm in your projects without any extra installation steps.

5. Install Bun (optional)

Bun is a fast, all-in-one JavaScript toolkit that has been gaining a lot of traction. If you want to give it a try, you can install it with its official script, which needs unzip:

sudo apt install -y unzip
curl -fsSL https://bun.sh/install | bash

The script

This is the complete script that automates the steps above. It asks for confirmation before each step and removes its temporary files on exit.

#!/bin/bash
#
# Author: Ángel Blanco
# License: MIT
#
# This script is provided "as is", without warranty of any kind. Use at your own risk.
#
# Source: https://angelblanco.dev/blog/install-node-24-on-ubuntu-24
#
# Usage:
#   curl -fsSL https://angelblanco.dev/scripts/ubuntu-install-node-24.sh | bash
#
# This script installs Node.js and several package managers.
# Run it as your non-root user: it asks for elevated permissions
# with sudo when needed.
#

set -e

# Basic confirmation module before executing the script.
confirm_action() {
    read -p "$1 (y/n): " choice < /dev/tty
    case "$choice" in
        [Yy]|[Yy][Ee][Ss])
            return 0
            ;;
        [Nn]|[Nn][Oo])
            return 1
            ;;
        *)
            echo "Invalid choice. Please enter 'y' or 'n'."
            confirm_action "$1"
            ;;
    esac
}

# You can configure these variables if needed
NODE_VERSION=24
NPM_PREFIX="~/.npm-global"
DEPS="ca-certificates curl gnupg"

TMP_DIR=$(mktemp -d)
trap 'rm -rf "$TMP_DIR"' EXIT

echo "This script will install Node.js and optionally other package managers."
echo ""

if ! confirm_action "Install Node.js version $NODE_VERSION?"; then
    echo "Skipping Node.js installation. Exiting."
    exit 0
fi

echo "Installing the dependencies needed to install Node.js..."

sudo apt update
sudo apt install -y $DEPS

echo "Installing Node.js..."
curl -fsSL https://deb.nodesource.com/setup_$NODE_VERSION.x -o $TMP_DIR/nodesource_setup.sh
sudo -E bash $TMP_DIR/nodesource_setup.sh

sudo apt-get install -y nodejs

mkdir -p ~/.npm-global
npm config set prefix $NPM_PREFIX
echo "npm prefix set to $NPM_PREFIX"

echo "Node.js installation completed."
echo "Node version: "
node --version

echo ""

if confirm_action "Enable Yarn and pnpm via corepack?"; then
    echo "Enabling corepack..."
    sudo corepack enable
    echo "Corepack enabled."
    echo "Yarn version: "
    yarn --version
    echo "PNPM version: "
    pnpm --version
fi

echo ""

if confirm_action "Install Bun?"; then
    echo "Installing Bun..."
    sudo apt install -y unzip
    curl -fsSL https://bun.sh/install | bash
    export BUN_INSTALL="$HOME/.bun"
    export PATH="$BUN_INSTALL/bin:$PATH"
    echo "Bun version: "
    bun --version
fi

echo ""
echo "Installation process finished."
echo ""
echo "Add the global npm bin directory to your PATH by adding this line to your .bashrc or .zshrc:"
echo 'export PATH=~/.npm-global/bin:$PATH'
echo ""

What about NVM?

Node Version Manager (NVM) is a fantastic tool for managing multiple Node.js versions. However, I personally prefer to stick to a single, system-wide installation of the latest LTS version. This approach forces me to keep my projects updated. Besides, Node.js rarely introduces major breaking changes in its LTS releases, so the upgrade process is usually straightforward.

If you prefer the flexibility of NVM, you can still use it, but you would likely choose one method or the other. After installing NVM, you would manage your package managers like yarn and pnpm by installing them globally via npm for each Node version you use. You could then use aliases to switch between different versions of your tools. Be aware that this can sometimes lead to path conflicts or unexpected behavior, so be mindful of which versions are active in your shell.

The 2020 decision: Why Svelte?

Back in 2020, when I built the first version of this site, the Vue ecosystem was in the middle of a big transition. Vue 3 was in beta, and it was released right after I had finished my website. The first two years of Vue 3 were painful, and Nuxt 3 wasn't stable until November 2022. The migration path from Vue 2 was uncertain, and frankly, the future felt a bit shaky.

At that time, Svelte and its companion framework, Sapper, were a compelling alternative: fast, simple and stable. It was the right choice for its time.

The tipping point: Ecosystem vs. DIY

Five years later, the tables have turned. Svelte is still a great framework, but the Nuxt ecosystem has grown to cover almost everything a site like this needs.

With my old Sapper site, I had to build many features from scratch: SEO meta tags, content management for the blog and image optimization. I learned a lot, but maintaining that custom code became a chore. On top of that, the migration from Sapper to SvelteKit was a big project that I simply didn't have the time for.

Nuxt, on the other hand, has modules that handle these concerns out of the box:

• @nuxt/content for file-based content management.
• @nuxtjs/seo for SEO and metadata, with defaults that work without any configuration.
• @nuxt/image for image optimization.
• @nuxt/icon for using any icon set without shipping the whole set.

With that covered, I can focus on writing.

Aligning with my daily workflow

The frontend side of my day job is Vue 3 with the Composition API, TypeScript and Tailwind. It makes sense for my personal site to use the same technologies I use every day. Working with Nuxt feels natural and simple, once you get its philosophy.

A quick look at the new stack

Nuxt is the core of the application. Tailwind CSS handles the styling, and daisyUI adds components and the light and dark themes. Turborepo manages the monorepo, which keeps the main app, the shared configurations and the internal tools in one place.

From Bulma to Tailwind CSS & daisyUI

In the previous version of my site, I used Bulma, and it's a great CSS library. However, my day-to-day work is rooted in Tailwind CSS. Switching between the template and a separate CSS file now feels like double the work, since you rarely reuse classes across .vue or .svelte components.

Because I use Tailwind every day, I've started to "think" in Tailwind when it comes to styling, and once you think that way, it's hard to go back. For this rebuild, I've paired it with daisyUI. It lets me opt in to pre-styled components when I don't want to overcomplicate things, and opt out to build something fully custom without losing any of Tailwind's benefits. It also comes with a theme system designed for Tailwind.

The role of AI in development

This rebuild was also a chance to try the latest generation of AI coding assistants. I've tried (too many) tools, like the Gemini CLI, Aider and GitHub Copilot. Some days they felt like superpowers, and others like the flu. If I stick to my goal of writing more, I'll tell you more about each of them soon.

What's next?

I want to write more, share some ideas I've been thinking about for a long time, and maybe start contributing to an open source project.

Thanks for reading. See you around.