Melabit

Siri AI and more on Apple Intelligence

Sat, 27 Jun 2026 18:00:00 +0000

Earlier today, I tried to activate Siri AI (Beta) on the Macbook Air M1 that I updated to Golden Gate a couple of weeks ago.

For now, and who knows for how much longer, here in Europe there’s no hope of using Siri AI on the iPhone or iPad due to the ongoing disputes between Apple and European regulators. But on the Mac, there shouldn’t be any issues, provided you use English as the language for both your Mac and Siri.

So, here I am again, heading to System Settings > Apple Intelligence & Siri — oops, on Golden Gate it has been renamed simply to Siri – to configure Siri so that it uses the same language as the Mac, which is already set to English.

Hey Siri (AI)

Nothing new so far. However, even though I was apparently placed on a waiting list to be notified when the new version of Siri would be available for my Mac,

after just a few seconds, a popup appeared allowing me to set up Siri AI right away.

As soon as I finished the setup, the System Settings > Siri pane changed to what you see below,

and, after the usual long wait for the language model download, my Mac running Golden Gate was finally ready to use Siri AI.

Now, I just need to find the time to give it a proper spin! 😇

Apple Intelligence on Sequoia

While I was doing all this, Apple Intelligence also got activated on the two Macs running Sequoia that I use daily for work. It all started with a notification on my Mac Mini M1,

and straight after that, the System Settings for Siri changed too, becoming as shown below.

The exact same thing happened on my Mac Studio M2 Ultra, which I hadn’t even touched yet.

It is clear that these changes were triggered by configuring Siri to use the same language as the Mac, in my case, English (though it obviously works for Italian and other major languages as well).¹

It’s strange, though, that this didn’t happen a couple of months ago when I did the exact same thing to use apfel and Apple Intelligence on the very same Macbook Air, which was running Tahoe at the time and has now been updated to Golden Gate.

But whatever the reason, Apple Intelligence’s Writing Tools are now working on Sequoia too,

even though, unfortunately, as already noted in my previous post on Apple Intelligence, they lack flexibility since there’s no way to change the default settings. Such flexibility is instead offered by apfel, which I can’t use here on Sequoia because it explicitly requires macOS Tahoe. Too bad!

Having activated Apple Intelligence now also allows me to use Image Playground on the Mac. Whether it’s actually worth using is a different story. In any case, it’s another tool to play around with, which never hurts.

Final thoughts

I didn’t know Apple Intelligence could work on Sequoia too. Reading the documentation, Apple Intelligence has been available in English since Sequoia version 15.1, released in late October 2024, while support for other major languages, including Italian, was added starting with 15.4 (late March 2025, now we are on 15.7.7).

But, partly due to the time that passed between the announcement and when Apple Intelligence actually became available here in Europe, and partly because Apple Intelligence requires both Siri and the Mac to be set to the same language, I had completely forgotten about it.

And I wouldn’t have noticed it today either, if I hadn’t seen the notification on the Mac Mini. A notification that definitely did not appear when, a couple of months ago, I did the exact same thing to try Apple Intelligence and apfel on the Air.

In any case, the requirement to use the same language for both the Mac and Siri just to activate Apple Intelligence is almost ridiculous nowadays. Using two different languages for your Mac and Siri might not be the norm,² but I’m certain it’s not such an isolated scenario as to not deserve the same attention Apple usually dedicates to other user niches.

As I noted in my post on apfel and Apple Intelligence, while you can set a Mac to use English and an iPhone to use Italian, Siri’s configuration is global. Therefore, once English is selected on any Apple device, the choice automatically propagates to all other devices linked to the same account. ↩︎
But I’m sure it’s quite common among those who, like me, work in software development and systems administration without being native English speakers. ↩︎

Golden Gate

Thu, 25 Jun 2026 18:00:00 +0000

The development of macOS has always followed a tick-tock pattern, more or less like Intel processors: the tick versions are more exciting and introduce new and spectacular features, while the tock versions are relaxed and focus on integrating these features into the operating system, fixing bugs and optimizing the overall behavior of the system to make it faster and more responsive.

In short, the tick moments innovate the operating system, but it’s the tock moments that make it great and memorable, as happened with Snow Leopard, Mountain Lion, El Capitan, Mojave, or Monterey.

– The Golden Gate Bridge under construction. Source: SFGate.

Golden Gate, also known as macOS 27, already seems to be on its way to becoming a tock. After the disasters of Tahoe, a version of macOS that addressed the many shortcomings (to put it politely) of Tahoe was just what was needed.

Isn’t it a bit early to make that claim? After all, I’ve only been using Golden Gate for a couple of weeks, and the developers’ beta is just on its first (since a couple of days second) version?

I’d say definitely not, and for a very simple reason: ever since updating to Golden Gate, I no longer pay attention to the user interface. I no longer notice the Finder toolbar, the myriad icons in the menus, or the many other graphic inconsistencies of Liquid Glass. I just focus on using my Mac for work.

After all, that’s how it should be. An operating system is not a showcase item, it is not a high-fashion dress that looks great but is impossible to wear. An operating system is the foundation on which a computer operates, and the more transparent it is, the better. If we don’t even notice the existence of operating system’s existence, as happened with the great macOSes mentioned above, this means it is fast and stable and does everything we ask of it without getting in the way or complicating our lives.

There will be time to examine the differences between Tahoe and Golden Gate in detail, but until then, kudos to the Apple developers for their excellent work. It wasn’t easy to fix Liquid Glass without discarding it entirely, but it seems they are on the right track.

A few words about WWDC26

Tue, 09 Jun 2026 18:00:00 +0000

I won’t make it long, just a few quick hot takes (or should I say lukewarm, since a day has already passed?) on what struck me most in the introductory keynote for WWDC26.

Parental Controls. Maybe it is because my daughters are already grown up, but I’ve always had many reservations about the effectiveness of parental controls. Kids easily bypass them, perhaps with the help of a nerdy friend, while parents gain a false sense of security and, worse still, use them to deceive themselves into thinking they have no responsibility for their children’s online activities.

We’ll soon see if this time Apple has gotten the right balance between control and freedom.

Siri AI. Speaking against Siri is like shooting the Red Cross, and since my daughter is a doctor, I won’t do that. That said, maybe this time we’ll finally be able to use Siri to interact more easily and quickly with our Apple devices, without the nonsense of the past.

I wrote we’ll be able, but the sad truth is that here in Europe we will have to wait who knows how long to be able to use Siri on iOS and iPadOS, while it should be available immediately on macOS. We’ll see.

macOS 27 Golden Gate. After the Tahoe disaster, and in particular the awkward implementation of Liquid Glass in macOS Tahoe, Apple seems to have listened to the criticisms of many dissatisfied users (I’m one of them, but I doubt Apple noticed), trying to correct the most glaring flaws of Liquid Glass.¹

The impression I got from the keynote is that Golden Gate is a version of macOS focused more on improving what’s already there than on introducing new features.

To me, this is very welcome news, given that these are the versions of macOS I loved the most and that I still consider the best, from Panther and Snow Leopard, to Mountain Lion and El Captain. As soon as I finish writing this, I’ll try downloading Golden Gate, so stay tuned!

Such as, for instance, macOS Tahoe: see you in September, macOS Tahoe: where is my Terminal?, macOS Tahoe, again, macOS Tahoe: let’s free the icons!. ↩︎

From HFS+ to APFS

Mon, 08 Jun 2026 06:00:00 +0000

For years I have had two external drives always connected to my home Mac Mini M1.¹ The first is a 2 TB external SSD containing all my work and personal documents, the code for the scripts and applications I develop, documentation, and so on.

A second mechanical drive keeps all my photos and music, as well as a large software library, mainly for macOS and Linux, which I started archiving more than twenty years ago, when you couldn’t find everything online, and which I still keep updating today.

This setup is necessary because the internal 1 TB drive is too small for my needs. But it also proves very useful every time I move to a new Mac: once macOS is configured and the essential applications are installed, I just need to connect the two external drives to be ready to work.

– Source: William Warby on Unsplash.

In terms of speed I don’t notice any significant difference between the internal drive and the external SSD. This is partly because the tasks I usually carry out, mainly writing and developing software, are not affected by the read or write speed of the drive. Even the media files on the mechanical drive aren’t an issue; when using Photos and Music I can surely afford to lose a few extra seconds.

Until macOS Monterey, displaying the contents of external drives was always almost instantaneous, even when dealing with folders containing thousands and thousands of files.

With Sonoma, suddenly everything changed. Every time I opened a folder containing a large number of files or subfolders, I had to wait several tens of seconds before being able to see the contents. Sequoia improved this behaviour sligthly, but only temporarily, as its latest releases have made opening folders on external drives as slow as before.

This slowness is not due to a hardware problem; the same drive connected to a Mac running Monterey displays files almost instantly. The problem lies in the software, or more precisely in how macOS manages the two main filesystems of the Mac world, HFS+ and APFS.

APFS

In 2017, after nearly twenty years of HFS+, Apple introduced a new filesystem optimised for solid-state storage devices, unimaginatively named Apple File System (APFS).

Up until Monterey the two filesystems coexisted peacefully: APFS had become mandatory for the system drive (that is, the one from which the Mac boots and which contains the operating system and applications), but nothing prevented you from continuing to use HFS+ for external drives, which in this way remained readable on older Macs and, with some effort, on Linux and Windows as well.

Starting with Sonoma (perhaps even from Ventura, which I always avoided using), access to the contents of folders on HFS+ drives became extremely slow. I don’t think Apple did this intentionally, perhaps to force users to switch to APFS. It is more likely that it was a simple bug that has never been fixed because Apple is no longer interested in supporting HFS+. In fact, the slowdown only affects the display of files in Finder, while opening or saving them is not affected.²

Due to laziness, I tolerated these slowdowns for two years. In the meantime, I replaced the 2 TB mechanical external drive with an NVMe SSD,³ but the speed at which folders opened improved much less than I would have expected.

So, a few days ago, I decided to take the plunge and convert both my external drives to APFS.

From HFS+ to APFS

With Disk Utility, switching from HFS+ to APFS is very straightforward: just right-click on the drive you want to modify and select Convert to APFS....

Before starting, it is useful to select the Show All Devices item from the View menu (or by clicking the View icon in the Disk Utility toolbar), so you can see how the structure of the drive changes as you switch from HFS+ to APFS.

In theory, the conversion process should not damage the files on the drive. However, it is better not to take risks and make a backup first. I write this from experience, as you will read shortly.

I had no problems with the first drive, the 2 TB SSD, perhaps because it was relatively empty with only 500 GB of the total 2 TB used. Converting from HFS+ to APFS took only a handful of seconds, after which the drive finally became fast and responsive, as expected of an SSD.

You can read but not write

The conversion of the mechanical drive was an entirely different matter. This drive, unlike the previous one, has only 500 GB free out of 2,000 total. But 500 GB is still a quarter of the total capacity and so, after the positive experience I had just had, I decided to start without making a backup, as the files it contained could always be restored from Time Machine.

When it went to convert the drive to APFS, Disk Utility started grinding away for quite a while; maybe it was only a minute or two, but a minute can feel like an eternity when you’re doing something like this. After that, Disk Utility stopped and warned me that the conversion process had failed.

Luckily, despite the error, the drive continued to work as usual. For that, I would like to thank the Apple developers, who did an excellent job of ensuring that the file system conversion – an extremely delicate process that modifies the underlying structure of the drive – could fail without damaging the files stored on it.

Needless to say, I tried again with the same result.

ABefore trying again, I decided it would be wiser to make a backup of everything onto another external hard drive first. This took the whole night, but it was better not to take too many risks.

It must have been a premonition, because on the third attempt Disk Utility gave up and reported an error -69860, “The underlying task reported failure on exit”, which was so vague as to be meaningless. However the consequence was clear: that the drive had become read-only. I could read all the files without any issue, but I could no longer write a single bit.

Since I had a fresh backup on hand, I didn’t panic too much. Using Disk Utility, I erased the entire drive, this time choosing APFS as the filesystem. To do this, simply select the drive and then click the Erase button in the Disk Utility toolbar.

Restoring the files

The next step was to restore the files from the backup. First, I tried using the Finder to manually drag each folder from the backup drive to the newly reformatted APFS drive.

There were no problems with folders containing relatively few files, but when it came to a much larger one, the Finder eventually gave up, claiming that the drive already contained a file with the same name. The file obviously wasn’t there because I was rebuilding the drive from scratch, but I didn’t want to waste any more time investigating, only to end up with the same error an hour later.

So, I opened the good old Terminal, moved with cd into the root folder of the drive to be restored (which I’ll call Media HD here),

% cd "/Volumes/Media HD"

and copied the folders one by one from the backup drive (Backup HD) to the destination drive. Before doing all this I reformatted again Media HD to start from a clean state.

% cp -p -R "/Volumes/Backup HD/<directory A>" .
% cp -p -R "/Volumes/Backup HD/<directory B>" .
...

Here, <directory A>, <directory B> (without the trailing /) and so on refer to the names of the folders (or directories) to be copied. The -p option specifies that the copy should not modify the file attributes,⁴ while -R means that all files and folders being restored should be copied recursively. Please note that the . at the end of each command is mandatory, as it specifies that the files must be copied into the current folder of the destination drive.

The great thing about using Terminal is that once you have started the copy process, you can set it aside and let it work while you do other things. Just make sure you don’t close Terminal or touch the backup or destination drives.

The downside is that you have no idea what is happening or how many files have been already copied. Using the -v option is out of the question, because it would cause cp to print the name and path of every copied file, slowing down the whole operation.

It is much better to open a second Terminal tab and navigate to the root folder of the drive being restored (if it doesn’t already appear automatically) with

% cd "/Volumes/Media HD"

and then run the command

% du -h -d 1 "/Volumes/Media\ HD/<directory A>"

which returns the list of folders contained in <directory A>, together with their respective sizes. The total size occupied by <directory A> is shown at the end. By comparing this with the size of the folder on the backup drive it is easy to get an idea of how much is left to copy.

One word of warning: when cp is busy copying a large file, du can be very slow to respond. Be patient and don’t worry, these are Unix tools, reliable stuff that crashes pnly when you hit them with a hammer!

Even the Terminal can act up

Although the Terminal is usually more reliable than the graphical interface, there are rare cases where it can cause problems.

It happened to me with a folder of about ten gigabytes, containing an enormous number of very small files arranged in deeply nested folders, which has always been difficult to transfer from one drive to another. Usually, the best thing to do is to compress the folder from the Terminal,

% tar -czf large_folder_with_many_files.tar.gz "Volumes/Media HD/Large folder with many files"

transfer it to the other drive and then expand again it with

% tar -xzf large_folder_with_many_files.tar.gz

I’ve done it many times before and it has always worked. This time, however, it didn’t. When I tried to decompress the file, a “Special header too large error” appeared, which could be related to some weird modification to the folder or its files that occurred while I was trying to convert the drive to APFS.

The problem here was that I could have all the backups in the world, but if I couldn’t decompress the file, I would have ended up restoring the folder from Time Machine, which would have taken an inordinate number of hours.

Luckily, on my Mac I always have a few utilities that I might rarely use, but that turn out to be essential when I need them. That’s the case with The Unarchiver by MacPaw, which is available on the App Store. Don’t ask me how or why, but The Unarchiver managed to unpack the tar.gz file without a hitch, and it did so very quickly, too, perhaps even faster than the usual tar command in the Terminal.

Conclusions

In the end, everything worked out fine, and I managed to convert my two external drives from HFS+ to APFS without losing a single bit of data and in less time than I would have expected.

Access to the drives is now lightning-fast again, just as it was in Monterey and earlier versions of macOS. I still don’t understand what happened inside macOS to make drives formatted with HFS+ so inefficient. I don’t think Apple did it on purpose to push users towards the new filesystem. It is far more likely to be a bug that Apple is no longer interested in fixing.

While my personal experience of converting from HFS+ to APFS is statistically insignificant, I believe it is reasonable to conclude that the conversion process should not cause any problems provided the disk is relatively empty (i.e. up to 50% full). I haven’t been gazing into a crystal ball; the reason is simply that, under these conditions, macOS should have ample space to create the data structures of the new file system without touching the existing ones.

Above that threshold the conversion might work or, as happened to me, it might throw errors. In that case it is better to play it safe and make a preventive backup rather than risk losing your documents or getting stuck in arcane repair processes that you never know how (or when) will end.

Many users love to live on the edge and consider backups to be a waste of time. However, backups are never a waste of time, they are insurance for your data. And, unlike regular insurance policies, they are free or almost so.

In any case, never panic if something unexpected happens. It’s better to take a break, think it over, and look up information online, because reacting (badly) on instinct can do more damage than has already been done.

There is also a third drive dedicated exclusively to Time Machine. But that drive is indispensable and doesn’t count. ↩︎
If you want to force someone to do something, it is better to do it properly, isn’t it? ↩︎
I was lucky to choose the right moment. Today, the same drive would cost more than twice as much, and it might not even be easy to find. ↩︎
File attributes are the metadata associated with a file that define its behaviour and access modes. These include the file’s creation and modification dates, read and write permissions, file ownership, and so on. ↩︎

Apfel, an apple for Apple Intelligence

Mon, 11 May 2026 06:00:00 +0000

– Source: Julian Zwengel on Unsplash.

One of the (few) reasons to switch to macOS 26 Tahoe is the opportunity to use the language model that powers Apple Intelligence.

Apple Intelligence is the final product, natively integrated into the Apple ecosystem, with which we can process text (but also images) directly on our device. For example, by selecting a section of text and right-clicking with the mouse to choose Show Writing Tools, we have at our fingertips a useful tool for summarising those mile-long documents or for rewriting hastily jotted-down sentences.

As shown in the figure below, these tools are not limited to Apple applications alone, but can also be used in third-party applications like Firefox.¹

The language model (LLM) behind Apple Intelligence is accessible through the Foundation Models framework. And it is precisely this framework that allows developers to integrate artificial intelligence functions into applications running on macOS 26 as well as on iOS and iPadOS.

A few months ago, Apple added a new action to Shortcuts that also allowed end users to use the Foundation Models framework, but it wasn’t something that was really within everyone’s reach.

A few weeks ago a new tool called apfel (“apple” in German), became available, with which anyone can use the LLM integrated in macOS Tahoe via the command line and also through a simple GUI.

Installation

Installing apfel is a breeze for those who already use Homebrew. From the Terminal you must first run²

% brew update
% brew upgrade

to update homebrew, followed by

% brew install apfel

to install the application itself. Those who don’t use Homebrew (but they should!), can install it following these instructions.

As already mentioned, apfel only works on Macs with macOS 26 Tahoe and Apple Silicon. If you try to install it on Sequoia you get this error message.

% brew install apfel
==> Fetching downloads for: apfel
✔︎ API Source apfel.rb                                                                        Verified      1.1KB/  1.1KB
apfel: A full installation of Xcode.app 26.4 is required to compile
this software. Installing just the Command Line Tools is not sufficient.

Xcode 26.4 cannot be installed on macOS 15.
You must upgrade your version of macOS.
apfel: This software does not run on macOS versions older than Tahoe.
Error: apfel: Unsatisfied requirements failed this build.

Configuration

Before using apfel you must either close and reopen the Terminal or open a new tab.³ But that’s not enough, you also need to activate Apple Intelligence on your Mac by running

% apfel --model-info

and following its instructions, visible in the image below.

Basically, you need to go to System Settings > Apple Intelligence & Siri, configure Siri to use the same language as the Mac (I had to do this because I always use the Mac in English with Siri in Italian) and then activate the switch related to Apple Intelligence.

Don’t trust the 100% complete text that appears immediately after activating Apple Intelligence. This is probably a bug, because shortly afterwards, macOS starts downloading the model and this takes a while.

Once the model has finished downloading, apfel confirms that we are ready to use the model, so we can begin.

Many different ways to use apfel

The simplest way to use apfel, which is also suitable for integration into a program, is to run the apfel command from the Terminal followed by the prompt within quotation marks. For example:

% apfel "What is the capital of Italy?"
The capital of Italy is Rome.

The apfel command has several useful options, well described in the README of the program. The most interesting options are listed below, where the symbol <n> represents the numerical value associated with the option:

--temperature <n>, sets the temperature of the response. A lower temperature (<n> close to 0) makes the response more repetitive, a higher temperature (<n> around 1 or more) makes it more random and unpredictable.
--seed <n>, sets the initial value of the random number generator used by the LLM. Fixing the seed value means that the same question will always produce an identical response.
--max-tokens <n>, sets the maximum number of tokens in the response. A low value of <n> makes the response more concise, a high value allows the LLM to generate a longer response.
--permissive, allows generating responses with less strict security filters. Frankly, I didn’t quite understand what it means in practice, but maybe I didn’t ask the right questions. In any case, it seems that the responses acquire a lighter and friendlier tone.

It is also possible to activate a server based on apfel, which can be queried via the curl command. The advantage in this case is that the response is a JSON file that can be easily processed automatically.

Alternatively, you can open a chat session in the Terminal via the apfel --chat command. This allows you to communicate directly with the LLM without putting questions in quotes. Here, you can use the arrow keys to scroll through the history of the current session and edit the previous questions.

Lastly, a GUI for apfel is also available. It’s a very basic GUI, so don’t expect the same level of sophistication as with Claude, Gemini, ChatGPT and the like.

Putting apfel through its paces

Before starting, it is worth noting that Apple’s language model, unique among those produced by the major companies in the field (OpenAI, Anthropic, Google, Microsoft, Meta, you know the names), does not require an internet connection to work, but runs exclusively on the machine where it is installed (with some caveats). A guarantee for the privacy of our data that only Apple can offer.

However, as it has to run on iPhones, iPads and Macs, the Apple model has strong limitations in terms of size and, consequently, processing capacity. This is a detail to keep in mind when evaluating what it is capable of doing (and not doing). But this is a problem common to all local models, i.e., those that can be run on our personal machines. Ultimately, it’s a choice between power and privacy, and it’s never an easy one.

But, aside from answering trivial questions like the ones above, what is apfel really capable of doing (and consequently the Apple language model that apfel relies on)?

Forget about using it for math, logical reasoning or writing code. Apple isn’t exaggerating when it writes that all these activities are beyond the scope of its model.

In italian, the usual test on the death of Marie Antoinette produces very variable answers, sometimes correct and sometimes completely made up. When using English it performs slightly better, but that is normal because English is the native language of all LLMs. Math is not its strong point, either. It’s not so much because the answers are wrong, but because they are sometimes wrong. Would you ever use a calculator that usually gives the correct result, but every now and then makes mistakes? Needless to say, writing code is not an option, too.

When staying within the capabilities declared by Apple, things go much better.

I tried having apfel summarize a long note I dictated on my iPhone while I was out walking and, despite the presence of many transcription errors, repetitions and uncertainties, it did an excellent job. The note in question contains material that is still confidential, so having the security that the text fed to the LLM will remain only on my computer is an added value that far exceeds the model’s limitations.

No problem also asking it to be more or less concise, which in many cases can be really useful. It is also very easy to change the tone of the response, converting in a few seconds what we wrote into a press release or into a text understandable even by grandma.

It also does well with translations, I tried English and German but there’s no reason to think it wouldn’t do the same with other supported languages.

The responses are a bit slow, but I only tested apfel on a MacBook Air M1 (the only Mac I upgraded to Tahoe) and I guess newer Macs could give better results in terms of speed.

Why apfel and not Apple Intelligence?

It is simple: because the Writing Tools integrated in Apple Intelligence have default settings that work well in most cases. However, only apfel allows you to define in detail what you want to achieve.

Indeed, if I ask the Writing Tools to summarize the same note as before in a way that even grandma can understand, it replies that it cannot do it, without any further explanation.

If I ask the same thing to apfel, not only does it summarize the text without hesitation, but since I asked the question in English, it also translates it into this language (part of the text in the image below is blurred because, as I said before, it contains information that is still confidential).

In short, Apple Intelligence is a tool that anyone can use immediately. However, if you need flexibility, apfel is without doubt the best choice.

Conclusions

Apple is right: its language model isn’t a general-purpose model capable of competing with ChatGPT, Gemini, or Claude. But it does well what it is supposed to do, and the fact that it runs on a Mac (or an iPhone or iPad) is an added value that more than compensates for its limitations.

According to Apple, only the most complex requests need to rely on larger models in the cloud. This seems to be true when using apfel: whenever I disabled the network connection, apfel continued to work without any issue. However, with the Writing Tools, it’s a different story because some functions are deactivated as soon as the internet connection is lost.

A difference in behavior that deserves further exploration.

When using apfel you have to deal with a certain slowness in responses. I used a MacBook Air M1, on a newer Mac the processing would certainly be faster. However, I doubt it will be much faster because, after all, we’re still using a personal computer and not a server farm that costs billions of dollars.

From my point of view, the most serious flaw of Apple Intelligence and consequently of apfel, is that you have to configure your Mac and Siri to use the same language. As this change is global, it affects all Apple devices connected to the account. I noticed this when Siri on CarPlay suddenly started to speak in English instead of my home language. Luckily I was alone, otherwise I would have looked like a stupid presumptuous nerd.

If I want to go back to using Siri in Italian (and I do), I will be forced to deactivate Apple Intelligence, at least until Apple decides to remove this constraint. A constraint that technically makes little sense and seems only a retaliation against the rules imposed by the European Union on Apple and its competitors.

If you don’t like the screenshot (I don’t like it either), blame the designers of Liquid Glass. ↩︎
The % symbol in zsh (or the $ in bash) represents the shell prompt and is not part of the actual command. I use it to visually distinguish commands executed in the Terminal. which are preceded by %, from their responses, which do not include it. ↩︎
It’s a small annoyance that applies to any application installed via Homebrew. ↩︎

How to install Homebrew

Mon, 11 May 2026 06:00:00 +0000

Installation

To install Homebrew, open Terminal, install the Command Line Tools for Xcode using the command

% sudo xcode-select --install

and then run the script

% /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

answering the questions that appear on the terminal. Once the installation is complete, it’s always a good idea to run

% brew doctor

to check that the installation process was successful.

Available formulas

The packages available in Homebrew (or rather, the formulas in the program’s terminology) are listed on this page, and can be installed from the Terminal using the command,

% brew install <formula name>

where <formula name> is the name of the formula to be installed. For example, brew install tree installs a (very useful!) program that displays the entire hierarchy of files and folders in a directory using a tree view.

Updates

Every now and then, it’s a good idea to update your installed packages (I do this about once a week) by running these three commands in Terminal,

% brew update
% brew outdated
% brew upgrade

which update the list of packages available in Homebrew (brew update), list the installed packages for which updates are available (brew outdated), and update the installed packages (brew upgrade).

When you run brew update, a list of new formulas available in Homebrew appears, which is useful for discovering interesting new programs. When you find one, just run

% brew home <formula name>

to access the program’s home page using your default browser.

Cask

Homebrew also lets you install and update many of the standard graphical applications available for macOS, such as 1Password, Chrome, or Zoom, from the Terminal. In Homebrew, these applications are referred to as ‘casks’. To do so, use the --cask option followed by the name of the program you wish to install. For example

% brew install --cask audacity

installs Audacity, one of the best audio editors currently available. The complete list of available casks can be found here.

If you prefer, you can use the graphical application Applite to search for, install, and uninstall casks, but in my opinion, that kind of misses the point of using Homebrew.

50 years with Apple

Wed, 01 Apr 2026 06:00:00 +0000

– The first image of an Apple II computer ever published in Bit, the most important Italian magazine dedicated to personal computers between the late 1970s and early 1980s (Bit no. 5, November–December 1979).

Fifty years ago, I was a spot-ridden high school student who wouldn’t have known about Apple until the early ’80s, when Bit —- the first Italian magazine dedicated to personal computers -— started featuring the first advertising pages dedicated to the Apple II computer.

– First advertising page dedicated to an “Apple Computer” (Bit no. 6, February 1980, back cover).

In those years, most of the coverage of the Apple II came from Bit’s main competitor, MCmicrocomputer, which, from its very first issue in September 1981, dedicated significant space to the California company.

In 1981 an Apple II with 48 KB of RAM, an 11-inch monitor and a floppy disk drive cost 5 million lire, more than a small FIAT city car, just to give you an idea. An amount of money that was out of reach for a university student like me, who could afford at most a Commodore 64 bought after winning on Totocalcio.¹

– The complete price list for Apple products from September 1981 (taken from MC Microcomputer no. 1, September 1981, page 84).

However, there were quite a few Apple IIs in the Physics Department, because they could be used to build the first automatic measurement instruments or to digitize images.² You just had to wander through the various labs to find one, and if you were lucky you could also use it when it was free.

One of the first Macintosh 128K arrived soon. I only managed to use it briefly, as it was stolen after a couple of days.

Shortly later, at my first conference, I noticed that Ken Gray, one of the most prominent speakers, had used a Macintosh computer to prepare both the article and the slides. Among a hundred participants, all with texts written on typewriters and images glued on, his work stood out and was immediately noticeable. The Mac sparked immediate sympathy between us two, so much so that he asked me to move to Chicago to work with him. But I had already accepted going to the Physikalisch-Technische Bundesanstalt (PTB) in Germany, and preferred to keep my word.

It was precisely at PTB that the turning point came in terms of Apple products. Besides sophisticated instrumentation and one or two older Macs, my measurement laboratory housed a Macintosh II, the first expandable Mac (at last!), a true workstation that could rival the much pricier Sun and DEC models. It had plenty of expansion options, which was great! I don’t remember if the Macintosh II was connected to a system for acquiring and processing images for a microscope, which was truly state-of-the-art at the time (once back in Italy, I spent years trying to create a pale imitation of it).

But I remember very well that it had an analogue-to-digital conversion card installed, which could be used to digitize measurements on our samples. This card arrived together with the first version of LabVIEW, the first visual programming language, which for that reason ran exclusively on the Macintosh. For various reasons we used the card little, but LabVIEW immediately became the favorite pastime of mine and a Danish colleague (and friend). In the evenings, when no one was around, we would spend hours using LabVIEW for the most absurd things, the further they were from the original purposes of the language, the better.

The Macintoshes in the lab were set up to use German, and System 6 at that time didn’t support multiple users and languages. But despite my German being very poor (very poor, actually) I managed to use the Mac without too many problems because I remembered the position of the menu items that I had seen in manuals or magazines. Compared to the proprietary Unix system localized in German that I was forced to use occasionally, it was truly another world!³

Back home, my Apple winter began. That lasted until the dawn of the new millennium. Apple computers had become incompatible with everything: keyboards and mice for PCs didn’t work on Macs and vice versa. The same applied to RAM or video cards. And also to more sophisticated stuff that I used every day, like data and image acquisition cards or instrument control cards. Even transferring a file via floppy from a PC to a Mac tested the patience (and stubbornness) of a saint.

Then came Mac OS X.

In the early ’90s I had discovered Unix, mostly because it was the only way to manage to do some rather complicated numerical calculations.⁴ So when Linux arrived, I immediately jumped on the bandwagon and started using it everywhere.

Technically Linux was awesome, but the graphical aspect was, shall we say, somewhat limited. Therefore, when I saw an iBook G3 “Snow” with Jaguar in a shop display and read in Macworld that the new operating system was based on BSD Unix, I knew I had to get one.

The same happened with the iMac G4: I saw it, fell in love with it and bought it immediately. And for weeks colleagues came to the office, admired the monitor and started looking for the computer… 😂.

Since then, and it’s been almost twenty-five years, I’ve always used Apple products: Macs, iPods, iPads, iPhones, Apple Watches, I’m surely forgetting something. After all, they work (almost) always, and even the most technology-resistant family members can use them without any problems. They’re elegant and, although they cost somewhat more than competitors’ products, they also last much longer. It wouldn’t make sense to change, at least for now.

Sure, Apple has recently made some questionable decisions, such as macOS Tahoe and Liquid Glass, the imminent discontinuation of Rosetta, the introduction of paid versions of Pages, Numbers and Keynote (not to mention Freeform), the growing restrictions on third-party applications, and the Siri debacle. Not to forget the restructuring of System Settings, which has made them difficult to use, even for someone like me who needs them almost every day.

However, until Apple decides to prevent the installation of third-party applications also on macOS, as happens (not always) rightly on iOS and iPadOS, it will be difficult to leave the mother ship. After all, just as in a marriage with its ups and downs, fifty years spent almost always hand in hand are not easily forgotten.

So many, many, many happy returns to Apple for the next fifty years!

– Fonte: Ray Hennessy su Unsplash.

If you compare the price of the base Apple II reported in this image with that of the advertisement on Bit, you’ll notice that in less than two years the price of the base Apple II had increased by a whole million lire (roughly 1,000-1,500 euros today) due to the rampant inflation of those years. ↩︎
It was the era of transition from human digitizers, who spent their lives bent over huge images that they digitized by hand, to semi-automatic digitization systems, which in the simplest cases were almost always Apple IIs. ↩︎
All shell commands were localized in German, so the standard whoami command, that shows the name of the logged-in user, became wobinich ↩︎
PCs were too slow. As if that wasn’t enough, and despite the threatening signs I left around, some colleagues persisted in turning off the PC on which I was running simulations overnight. They didn’t want to “waste electricity”, they said 😱. ↩︎

Antigravity: the LLM does it better

Mon, 16 Mar 2026 18:00:00 +0000

Over the last few weeks, I’ve been writing about my experiments with Antigravity, or rather, with the (more or less) intelligent agents integrated into the editor. The results have been mixed: sometimes the agents proved to be very effective, accurately easing some complex or repetitive tasks; in other cases they didn’t accomplish anything worthwhile, only wasting a huge amount of time.

Coding badly with an LLM

Among all the more or less useful applications of LLMs, one of the most controversial is the idea that anyone can use an LLM to program, even when they don’t know the first thing about it. This is the so-called vibe coding, a concept that can be summarized more or less like this: “I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works”. This is not a quote from Nanni Moretti, a famous italian actor and director; it was reported by Andrej Karpathy, one of the founders of OpenAI.

Now, setting aside the many issues regarding security, the maintainability of code produced without really knowing what it does, and the regression to the mean, which here implies that the quality of AI-produced code will inevitably tend to collapse, it only takes a bit of personal experimentation, even with simple projects, to realize that the very idea of coding for everyone doesn’t work. If you want to get something good out of AI, you have to know exactly what you want and how you want it.

I tried vibe coding myself: I asked Gemini to write a driver for an Arducam camera, explaining only the bare essentials and waiting for it to do everything on its own.¹

However, this approach did not work. It took hours upon hours of work, errors, inconclusive answers, corrections, and advice from me to reach an acceptable result.

And this was only possible because I eventually abandoned the idea of letting Gemini do everything and provided it with specific advice on how to proceed. Without that, it would have only been a massive waste of time.

Mimmo also tried, on his own, to have Lumo write a Micropython program to manage my Arducam Mini 5MP Plus with the Pico. Even Lumo, which is undoubtedly one of the best chatbots around, couldn’t do it.

– Image generated by Google Gemini.

Coding better with the same LLM

This doesn’t mean that an LLM can’t be useful when programming; you just have to use it properly. You must explain exactly what you want it to do, provide all the necessary materials, and set boundaries within which it must operate.

In short, you have to treat it like a graduate student or an intern, with little experience but a great desire to learn.

It only took two carefully written prompts to make a difference. The first defined the project’s directory structure and instructed the agent to use git for version control and uv to install any necessary Python packages,

Prompt

Start a new project and name it project13-pico-camera5mp-reprise.

Read the AGENTS.md file that defines your basic behaviour.

Create a new directory with this name and initialize an empty git repository using git init Use uv for managing Python packages. All the code must stay in the code directory, with no subdirectories within it. This project does not need a data directory and the output directory must be renamed as images.

while the second prompt contained everything I could think of to help it work.

Prompt

I have a Rasperry Pi Pico 2W connected to a Arducam 5MP Plus OV5642 Mini Module Camera Shield (https://www.arducam.com/arducam-5mp-plus-spi-cam-arduino-ov5642.html).

I have connected the camera to the Pico using the standard layout found in the documentation:

Camera	CS	MOSI	MISO	SCK	GND	VCC	SDA	SCL
Pico	GP5	GP3	GP4	GP2	GND	3V3	GP8	GP9

The main documentation for the camera can be found at these links:

The code to drive this camera with the Pico is written in C (i.e., for Arduino) and CircuitPython, and can be found here: https://github.com/ArduCAM/PICO_SPI_CAM. You can download all the files you need from this repository. In particular, the files for CircuitPython are in the Python directory:

Arducam.py, which contains the functions to drive the camera,
OV5642_reg.py which, as far as I have understood, defines the resolutions allowed when taking pictures, and
boot.py , but I don’t know what it does. In the same directory there is also the script ArduCAM_Mini_5MP_Plus_VideoStreaming.py which sends the video captured by the camera to a Windows application and that is of no use here.

Please write a basic CircuitPython script that uses the functions defined in Arducam.py to test that the camera works and can take photos.

These two better-crafted prompts allowed Gemini 3 Flash to quickly generate a CircuitPython script that runs directly on the Pico and performs all the requested tasks.

Actually, the very first version of the script didn’t work. But Gemini was able to modify just a single line in the Arducam.py driver provided by the manufacturer to fix it (specifically, it removed a zero from the frequency value).²

– The line highlighted in blue shows the only change that Gemini made to the Arducam.py file; the original file is on the left, and the Gemini-modified version is on the right.

All of other files provided by the manufacturer remained intact.

As it turned out, the manufacturer’s driver worked perfectly with the Pico. Gemini simply learned how to use it to write the script that captures the image directly from the microcontroller (with a bit of patience, I could have done that myself).

Guide the LLM or let it run on its own?

The difference with respect to the previous approach based on vibe coding is striking.

Then. Gemini worked frantically for hours and created such a mess that I was forced to restart my Mac twice. Meanwhile, it had convinced itself (and me, too) that the Arducam.py driver was incompatible with the Pico and thus rewrote it from scratch, discarding an essential library for communicating with the camera (the library marked by the red arrow),

– Changes to the first few lines of the Arducam.py file; original file on the left, Gemini’s modified version is on the right. The arrow marks the library that was removed by Gemini.

and removing most of the functions defined in that file for no reason and without any real gain in efficiency or functionality (quite the opposite, actually!). The image below shows the difference in the length of the original code, on the left, compared to the modified version, on the right.

– Changes to the Arducam.py file. The red rectangles highlight the difference in the number of lines between the original code (left) and Gemini’s modified version (right).

Not satisfied with that, Gemini also completely altered the OV5642_reg.py file containing the camera configuration data, claiming memory issues. These problems evidently didn’t exist, given that everything went smoothly in this second experiment using the manufacturer’s original file.

– Changes to the OV5642_reg.py file, containing the camera configuration data. The original configuration (left) was overridden by Gemini (right).

What About Arduino?

At this point, it was inevitable to ask Gemini to generate the Arduino driver, using the same information that I had already provided for CircuitPython.

At this point, it was inevitable that I would ask Gemini to generate the Arduino driver using the same information that I had already provided for CircuitPython.

Gemini struggled more this time, mostly because I had forced it to make only minimal changes to the original Arducam libraries. However, this constraint was impossible to satisfy since the libraries do not natively support the Raspberry Pi Pico.

Response

Researching Arducam Library Compatibility I’ve thoroughly inspected both the original ArduCAM library and the Arducam_mini library. Neither version contains native support for the RP2040/RP2350 (Pico) architecture. Specifically, both libraries are missing the necessary definitions for regtype, regsize, cbi, and sbi for this platform, which is the root cause of the compilation errors.

Once the constraint was relaxed, things went smoothly, and in a short time, the driver modified specifically for the Pico and the related image acquisition program were ready.

Free or paid?

Many argue that paid models are much better than free ones. Consequently, my vibe coding problems would supposedly have disappeared if I had paid for Gemini or Claude.

That’s not exactly how it went. During my testing, I mainly used the free version of Gemini to see what would happen to a non-professional user playing with these tools. However, when I ran out of tokens, I switched to the paid version of Gemini provided by the university, but I never noticed any significant differences. I can’t say much about Claude, because paying 200 dollars a month to use it seriously makes no sense for someone like me, who isn’t a professional programmer.

What I did notice was that Claude Opus and Claude Sonnet were much better than Gemini at solving the problems that arose during code development. However, since I only used them once the work was already in progress, they might have just been helped by what Gemini had already done.

Conclusions

It goes without saying that neither this experiment nor the previous one are scientific. For them to be considered as such, I would need to use different types of microcontrollers and modules, define a well-defined set of prompts, and measure how the agent responds to changing experimental conditions.

Despite this, the experiment has one merit: it is fully reproducible. Anyone can repeat the experiment using the same low-cost hardware and prompts to verify whether my findings are correct.³

This is something that the vibe coding apostles with tens of millions of views always carefully avoid proposing. Their posts are full of certainties and bold predictions yet they never provide any evidence to support their claims.

Today, no one can deny that LLMs can be a great help during programming. However, it’s hard to believe that they can truly do so without any human intervention. At least until those apostles decide to provide us with clear, repeatable data to support their claims.

Although I know a little bit about programming, I had no idea how to develop a driver and didn’t want to spend days learning how to do it. ↩︎
Actually, this file is a library of functions. However, since microcontrollers don’t have an operating system, these functions access the hardware directly, just like the drivers that control the components of a computer. Therefore, in this case, the terms library and driver are interchangeable. ↩︎
The term low cost must now be taken with a grain of salt. The shortage of electronic components has caused the price of the Pico to skyrocket, and even more so for the Arducam Mini 5MP Plus. The latter, which cost 40 dollars a few months ago, now costs more than triple that on Amazon or AliExpress. Fortunately, some retailers are maintaining more reasonable prices, at least for now. ↩︎

The Dory effect

Mon, 09 Mar 2026 18:00:00 +0000

I am well aware that LLMs have poor memory, but I never imagined that I would suffer the consequences so quickly.

– Immagine generata da Google Gemini.

Note to the reader. This article complements the previous one, Antigravity: a driver written by AI, and should be read afterward. However, here’s a brief recap for the lazy readers.

Not knowing how to write a driver for a SPI camera attached to a Raspberry Pi Pico, I asked Gemini 3 Flash for help, working entirely inside Antigravity. After many hours, the agent managed to produce a working Arduino program. Then I made a fatal mistake by asking for even more without taking any precautions.

Premise

The working code generated with such great effort by Gemini 3 Flash assumed the Pico acted as a bridge between my Mac Mini and the SPI camera.¹ On the Mac, a Python script commanded image capture, while the actual acquisition was performed by the Pico, running an Arduino program (a sketch in platform jargon) that is essentially C/C++ code adapted for microcontrollers.

Controlling everything from a PC works fine for early tests, but it becomes cumbersome when you want to use such a setup for fieldwork.

Automatic captures

I asked Gemini to modify the code so it would automatically snap an image every N minutes or when a button is pressed, then send the picture to a computer over Wi‑Fi.²

Prompt

[...] However, this means that I need to use a Pico for the capture and another computer, even a Raspberry Pi Zero for commanding the capture process. Would it be possible to do everything on the Pico, eg press a button and perform the capture or via a timed process (defined in the .ino file itself) every N minutes (but there should be a mechanism that sends the images to a computer connected by WiFi, avoiding to fill the pico storage space).

Gemini jumps straight into the work, still using Arduino. In principle, it should be a trivial task, but no matter how hard Gemini tries, the code never works. After many fruitless attempts I got fed up and asked it to revert to the last known‑good version of the program.

Backtracking

And here Gemini hits an unexpected wall because, despite my guidance and constant suggestions, there is absolutely no way to succeed.

Stupidly, I hadn’t kept track of the various code versions as they were generated, and that’s entirely my fault.

On the other hand, even though I am well aware that large language models (LLMs) have a working memory that resembles Dory’s, the blue tang fish, I would have never imagined that these ultra-sophisticated systems couldn’t even retrospectively reconstruct what they’ve already done. Despite having dozens upon dozens of implementation_plan.md, task.md, and walkthrough.md files that detail every previous step. I counted them: for this project alone, Antigravity produced over 250 distinct files.

Going back to a prior state is something that tools like Git and its predecessors – tools that are entirely devoid of any intelligence beyond that of their creators – have been doing flawlessly for more than fifty years). Maybe developers of these intelligent agents could give it a thought, huh?

Epilogue

In the end, stubbornly relying on my notes,³ I managed to get Gemini to repeat everything it had already done. It took hours, it reproduced all the earlier mistakes, but eventually the rebuilt code worked again.

While I was at it, I also had Gemini redo the whole thing for CircuitPython, and that port required many other hours of work and errors. And before getting there, Gemini caused such severe issues that macOS had to disable USB communication with the Pico, forcing me to restart the Mac a couple of times.

Needless to say, this time I had it keep track of every step with git and I also put all the code on GitHub, just in case.

One of the next steps will (hopefully) be MicroPython, but that’s another story.

Why does Arduino struggle so much, despite being a far more mature microcontroller development platform than MicroPython or CircuitPython? Because the camera module I chose isn’t supported on the Raspberry Pi Pico; it only works with classic Raspberry Pis (those running a full OS, such as the Pi 4, 5, or Zero), as well as with the Arduino and ESP286 families of microcontrollers. ↩︎
English isn’t great here; it’s more a stream of thoughts than a polished discourse. But I prefer jotting down whatever comes to mind while writing rather than losing the thread of ideas. ↩︎
I’ll never stress enough how important it is to keep written notes of what you’re doing. At the beginning it seems like a waste of time, yet it’s the best way to avoid losing a huge amount of time later. ↩︎

Antigravity: a driver written by AI

Wed, 04 Mar 2026 18:00:00 +0000

Among all the Raspberry Pi and Arduino boards I am spending my days with, my favorite is the Raspberry Pi Pico, a small yet powerful microcontroller that can be programmed not only in C/C++ via the Arduino IDE, but also in MicroPython and CircuitPython, two competing Python variants for microcontrollers.

Unlike the other Raspberry Pi models, the Pico does not have a dedicated camera interface, but it can use cameras that communicate over an SPI interface,¹ such as the Arducam Mini 5MP Plus.

In theory, this shouldn’t be a hard job. After glancing at the official documentation, it should just be a matter of wiring the camera to the Pico, pulling the driver and test programs from the manufacturer’s GitHub repository, copying them onto the Pico after installing the supported Python version, and finally trying to snap a few pictures.

I couldn’t have been more wrong.

We need a driver

The only two test programs available, one for Arduino and one for CircuitPython, assume you’ll view the video output on Windows, which is odd because most people working with these devices use Linux or macOS. Moreover, CircuitPython is less common than MicroPython, and I’d have preferred the latter for compatibility with the other components already connected to the Pico.

With patience, and armed with a reference program that shows the main functions for handling the device, you could try translating the CircuitPython code to MicroPython (or vice‑versa),² but there was nothing like that available.

Other guides I found online looked promising, yet they didn’t work in practice. The only option left was to bypass the official tools and write a driver for the camera.

Easier said than done!

I know how to write code to solve differential equations or analyse measurement data. I’m comfortable with micro‑controller programming and sensor data acquisition. But this is a completely different beast. It requires digging into the low‑level communication between the Pico and the camera, a job for specialist engineers who write the drivers that let us humans perform complex operations (like taking a photo) with just a few lines of Python code.

So why not let one of the agents built into Antigravity do what I’m not able to do?

I didn’t have to stick with Antigravity, Claude Code, Google Gemini, DeepSeek, or any of the countless other LLMs at our disposal could have easily handled the task. However, as I’ve already written, using an Antigravity-integrated agent lets you work directly in the editor and access the underlying OS, a huge advantage when you need to keep iterating on the generated code.

AI at work

When you read countless enthusiastic posts about vibe coding – the notion that AI can develop software with little to no human programmer intervention – it looks very easy (read for example, this post that amassed millions of reads, or this one; not to mention the tweet that started it all).³ In summary, you write a couple of sentences asking the LLM or the current agent to do something, you go have lunch or take a walk, and when you come back everything is ready.⁴

Let’s try doing the same with Gemini, giving it only the essential information and checking what it can actually do. In this case, this information boils down to the link to the camera’s web page and a table describing how the camera pins are connected to the Pico (it’s more than three lines, I know, but I’m a bit verbose).

Prompt

I have a Rasperry Pi Pico 2W connected to a Arducam 5MP Plus OV5642 Mini Module Camera Shield (https://www.arducam.com/arducam-5mp-plus-spi-cam-arduino-ov5642.html). I have connected the camera to the Pico using the standard layout found in the documentation:

Camera	CS	MOSI	MISO	SCK	GND	VCC	SDA	SCL
Pico	GP5	GP3	GP4	GP2	GND	3V3	GP8	GP9

Please write a basic Micropython code to test that everything is right and that the camera can take photos

Gemini attacks the problem furiously, spits out MicroPython code that doesn’t run, tries to fix it based on my hints, and inevitably introduces new errors (I keep saying Gemini for brevity, but I’ve also tried Gemini 3.1 Pro, Claude Opus 4.6, and Claude Sonnet 4.6, as my tokens ran out).

At some point, completely stumped, Gemini starts suspecting a hardware issue, such as a bad connection or a defective camera (but probing the individual pins quickly finds that everything is wired correctly).

After hours and hours of work, and because it can’t produce anything decent with MicroPython, I ask it to switch to Arduino, a more mature software platform. More hours later, stubbornly, it succeeds, and the image below is the very first picture ever taken with the Arduino code generated by Gemini (the original image was upside-down; I simply rotated it 180°).

Soon after, I make a serious mistake that forced me, or better it, to start from scratch. But that’s a story for another post.

Epilogue

Once I had a working Arduino program, I asked Gemini to redo everything for CircuitPython. This port also takes several hours of work, interspersed with a couple of forced restarts of the Mac which, after some nasty CircuitPython bug, was forced to disable communication between the USB ports and the Pico.

In theory I should repeat the cycle a third time for MicroPython. But the thought of wasting even more time watching Gemini work makes me shiver, so I shelved that idea, at least for now.

Conclusions

I don’t know what those who write countless articles proclaiming that anyone can have AI write a perfectly functioning program in no time, even if they don’t know a thing about programming, are using.

Even though I know something about programming, I’ve only succeeded with the simplest experiments described in the two previous articles. And it certainly didn’t happen here. It is worth noting, however, that I’m in good company.

– Immagine generata da Google Gemini.

True, following the vibe coding mantra to the letter, I didn’t write a single line of code. I even let Gemini execute terminal commands that I could type blindfolded. But it’s equally true that without my constant dialogue, without guiding the agent step-by-step, without correcting its countless, and often trivial, mistakes, Gemini would have gone nowhere.

And it took many hours of uninterrupted work, too many hours in my humble opinion, to achieve something usable.

Forget speedy, intuitive programming. Forget coding based on good vibrations from the 1960s. Forget programming for dummies!⁵

If you don’t roll up your sleeves and get your hands dirty with the code, even code produced by a more or less intelligent agent, you won’t get you anywhere. I’d love to be proven wrong.

The SPI (Serial Peripheral Interface) is a fast and reliable serial communication protocol widely used to connect a microcontroller (master) to one or more peripheral devices (slave). ↩︎
While writing the article I found this video that explains how to mix MicroPython and CircuitPython code in the same script. If it works for more complex tasks than toggling an LED, it would be a real breakthrough. ↩︎
Is it a coincidence that they are always very long posts but never contain a shred of evidence, a prompt, a few lines of code, or links to support the many unverified (and unverifiable) claims? ↩︎
Being true nerds, no one ever says they’re going to have sex. ↩︎
From the title of the famous For Dummies book series, covering everything from using DOS to playing chess. ↩︎

Antigravity: from surprise to doubt

Mon, 16 Feb 2026 18:00:00 +0000

As effective as Antigravity may be, digging a little deeper reveals that the agent-based systems working inside it, while helpful and capable at answering many complex questions, are not exempt from the usual issues of the large language models (LLMs) we’ve been dealing with for the past three years.

Let’s look at some practical examples.

– Image generated by Google Gemini.

Example #1

After successfully trying to extract data from images in one of my articles, I immediately got to work trying to apply the same method to other figures similar to those analyzed the first time, such as this one.

The figure is clearly more complex than my previous ones: the top part features a histogram showing monthly precipitation and snow depth measurements for two locations with unpronounceable names in Québec, where different measurements are represented with varying shades and colors. Below it, and partially overlapping the histogram, there is a line graph with the average monthly temperatures for the two locations, with the vertical scale positioned on the right side.

Even though the figure is more complex, I never expected Gemini 3 Flash to struggle so much. It tries, and tries again, but every time something is off. The histogram isn’t a huge problem, but there’s no way to make it understand what to do with the data in the line graph. This issue persists even when I explain exactly where it should look to determine the temperature values for each month.

Prompt

Hint: To evaluate temperatures for a given month you should take a point on the temperature plot that is between the two precipitation bars

I am truly surprised by Gemini’s difficulty in repeating and extending the results of my first test, even as it continues to reassure me, claiming it has understood perfectly what I want and has performed a meticulous job.

Answer

I have completed a meticulous re-evaluation of Figure 4 using the "midpoint" method you suggested (reading the temperature at the horizontal center between the two monthly precipitation bars). Final Corrections Applied: [...]

Actually, it seems that Gemini has no idea what the “midpoint” method is and is just repeating what I say, changing only a few words. If it were otherwise, it would have resolved the issue in seconds, pulling out the right data just as it did the first time.

In the end, I give up. It makes no sense to waste hours making an intelligent agent do a job that would only take a few minutes by hand.

Example #2

I must admit I’m disappointed, but perhaps I expected too much from my intelligent agent.

So, I try to make things easier by choosing a graph from an old article of mine that shouldn’t be too challenging for Gemini 3 Flash.

Instead, it gets stuck and makes incomprehensible mistakes. With a little help, he manages to pull out the data shown in this graph, which still has several missing points (highlighted by the colored boxes) or, even worse, points added quite imaginatively (such as the one indicated by the arrow).

Another disappointment. Why use an intelligent agent if it’s faster to acquire the points by hand?

Example #3

But I don’t give up easily and try once more to get it to do something good. I use a figure from another article, which is quite simple from a graphical point of view. However, it would be useful to be able to acquire it automatically, as the amount of data it contains makes it difficult to digitize accurately by hand.

Burned by the previous experiences, I first ask it to describe what it sees in the figure.

Prompt

Now could you describe in simple words what you "see" in figure 1?

The response is long, precise, and almost flawless,

Answer

Looking at figure 252505_1_f1.jpeg, I can see:

Two side-by-side graphs showing current-voltage (I-V) characteristics:

(a) Left graph (T = 2.0 K):

Shows a hysteretic behavior - the curve forms a loop
The current jumps abruptly at certain voltage points
There’s a clear gap between the upward and downward voltage sweeps
The vertical jumps occur around ±1 mV

(b) Right graph (T = 5.8 K):

Shows non-hysteretic behavior - smooth, continuous curve

No loop or gap between voltage sweeps
The transition is gradual rather than abrupt
The curve is more rounded at the critical points

Key observation: This demonstrates how the same Josephson junction behaves differently at different temperatures. At the lower temperature (2.0 K), it shows hysteresis (memory effect), while at the higher temperature (5.8 K), the hysteresis disappears and the junction becomes “overdamped.”

Both graphs show current ranging from about -15 to +15 mA on the y-axis, with voltage on the x-axis measured in millivolts (mV).

but, in reality, there is an error at the end of the response that would render any attempt to digitise the data in the two graphs impossible.

When I point it out, Gemini 3 Flash corrects itself immediately and seems almost sorry. But, as we all know, LLMs are programmed to always please the user.

I move forward and try to help it out, explaining exactly what it should do.

Prompt

No problem. Now could you extract the values of voltage and current from the two images? Please produce a table for each image, and export the table as a csv file and a markdown file, with suffix `_table`.
Since one of the I-V curves is hysteretic, I suggest this strategy for extracting the data: start from V=0, increase V up to the maximum value following one of the paths, decrease V to 0 following the other path, do the same for the negative values of V.

But despite the suggestion, there’s no way to get it to do a decent job. The best I get is this, which at first glance looks like a great result.

It’s a pity, though, that there’s a serious and incomprehensible error, which I’ll leave it for you to discover.

In any case, the previous image is truly the best of the best of the best, and it was obtained after hours of failed attempts (like this initial attempt, or this, or this one) and of hints that went from vague to increasingly precise, much like with an unprepared student from whom you try to get a few words out. Not to mention responses that always tried to adapt to the current suggestion without ever, or almost ever, making use of what had been discussed previously.

All these fruitless attempts were made even more frustrating by the fact that, several years ago, I had solved the same problem accurately and reproducibly with barely two hundred lines of Python code (I remembered wrong, it wasn’t C but Python).

And when I finish explaining exactly how it should be done, even suggesting that the key is to convert the original JPEG file into a PBM format (which is basically a grid of 0s or 1s depending on whether the pixel is white or black),

Prompt

My suggestion is to change focus completely. If I were you I would:

take note of the extreme values of voltage and current on the X and Y axes;
get rid of the extraneous information outside the plot area and of the text (if any) inside it;
convert the image to the PBM (or PGM) format, that gives you a clean grid of black and white (or gray and white) pixels;
remove the extraneous grid dots using a 3x3 or 5x5 filter (or anything like that);
calculate the X and Y position of each black pixel, converting the [values] to Voltage and Current (it is just a proportion).

Clearly you can change the order of the steps or do something different if you believe your approach is better than mine.

there’s still no way to get it to do something useful.

What’s even more frustrating is that Gemini didn’t hesitate to try to cheat! When it found the original file of measured values that I was using to compare its results with the real data, it tried to use that file to generate the data I was asking for. Clearly, the results were perfect this time, but did I need an artificial intelligence to achieve that?

Further examples

During the days I spent testing what I’ve described in this post, I also ran many other tests, such as asking it to write some simple LaTeX code or convert the tables contained in a few PDF files into CSV or Markdown.

t handled LaTeX well, but often struggled with tables, even when the layout was simple. There’s no need to go into detail here, as there aren’t many differences compared to previous examples.

Conclusions

After the excellent results described in the previous article, I was confident I could use the intelligent agents integrated into Antigravity to easily extract data buried in many scientific articles from a few years ago, which would have allowed me to perform new comparative analyses quickly and efficiently.

Unfortunately, all the more in-depth tests described in this post turned out to be unsuccessful.

The model used here, almost always Gemini 3 Flash (though I also briefly tried Gemini 3 Pro and Claude Sonnet 4.5),¹ showed inconsistent and unrepeatable behavior. For example, it would use different methods to solve the same problem without it ever being clear whether the choice of an algorithm or library had a specific technical motivation or was just a matter of statistical probability in the generation of responses.

Another serious issue was the lack of memory, much like Dory, the funny fish from the cartoons. Despite successfully solving the problem of extracting data from a histogram just a few days earlier, Gemini was unable to apply the same methodology to a similar case. On other occasions, once a problem was partially solved, Gemini would start working on it again from scratch instead of refining and improving the previous answer.

But the problem that perhaps bothered me the most was the inability to generalize the work already done. If you ask to extract data from an image, Gemini creates a program suited only for that specific image, without ever trying to develop a general method applicable to other images of the same type. Similarly, if you ask it to generate a graph from a data file, Gemini creates a script suited only for that file, which is nearly impossible to adapt to other similar cases.

When humans tackle a problem, they tend to become fond of the solution and try to reuse and extend it to similar problems. An LLM doesn’t care; it reinvents the wheel at every new iteration. It seems the triumph of the throwaway culture, a waste of resources and intelligence (however artificial) taken to the extreme.

I’m just a guy playing around with these tools. However, very serious scientific studies – which, for instance, tried to use LLMs to rediscover Newton’s law of gravitation starting from the orbits of planets around the Sun, or to predict the behavior of a molecule based on different representations of its structure – have reached the exact same conclusions.

Our analysis reveals that these models instead behave as if they develop task-specific heuristics that fail to generalize.²

Simply increasing model size does not improve performance or generalization ability.³

Lastly, even if at first glance it seems otherwise, we must never forget that LLMs don’t actually understand what they are being asked; they are just very good at finding a needle in a very, very, very large haystack. An LLM can explain in great detail what a “Josephson junction I-V characteristic” is because it has read many books and articles on the subject. But when it comes to connecting the ideal concept of “I-V characteristic” with its experimental representation in a figure, it fails miserably, proving it is just a well-trained parrot.

Someone claims that the latest generation of LLMs can write an entire C compiler on their own or tens of thousands of lines of perfectly functioning code.

Personally, I would be satisfied if these models could produce a data file or a table in a reproducible manner, without running into inexplicable errors or inconsistent results. They should also avoid awkward situations like the ones I experienced, where one day everything goes smoothly, and the next day, nothing works.

I also used the paid version of Gemini, kindly provided by my university, without noticing any differences compared to the free version. Those who claim that paid models do things the free ones can only dream of should provide solid evidence before being believed. ↩︎
K. Vafa et al., What Has a Foundation Model Found? Using Inductive Bias to Probe for World Models, arXiv 2507.06952v4, 2025. ↩︎
B. Yan et al., Inconsistency of LLMs in molecular representations, Digital Discovery vol. 4, 2025. ↩︎

An unexpected Antigravity

Wed, 21 Jan 2026 18:00:00 +0000

I confess, when I started using Antigravity I had many doubts, because the new revolutionary editor produced by Google seemed to me like just another clone of Microsoft’s VS Code.¹

But as soon as I started using the agentic features of Google Antigravity, I had to change my mind, because there is truly something good there.

Of course, there are also many limitations, but these are shared by all other LLMs (Large Language Models), which work well when guided step-by-step through the task at hand, but also lack imagination and struggle with new and slightly complicated problems.

– Image generated by Google Gemini.

Editor and IDE

Google Antigravity is an IDE (Integrated Development Environment), that is, an editor with additional features that help write and debug code.

Being a derivative of VS Code, it inherits all its positive and negative aspects, first and foremost the fact that it is based on Electron, a multi-platform framework that is very convenient for developers but also very demanding in terms of resources and disk space.

In fact, as I already noted in my last post, once installed, Google Antigravity occupies a whopping 700 MB on my Mac (696.6 MB to be precise), a hair more than VS Code itself (683.9 MB) and slightly less than its father Windsurf (718.7 MB). For comparison, my two favourite editors, TextMate and BBEdit, occupy 40 MB and 65 MB respectively. ²

There is little to say about the code editing and development support features. They are identical to those of VS Code and can be greatly extended through the 8,500+ extensions available on the Open VSX Registry, a database of extensions specifically designed for VS Code-derived editors.

In theory, one could use VS Code extensions, but Microsoft recently blocked the use of the VS Code marketplace for all other derivative editors (including Cursor, Windsurf, or Antigravity). So much for open-source principles…

Agentic functions

So, what exactly is Agentic Artificial Intelligence? It is an AI system that can act autonomously and achieve complex goals with minimal human supervision, without needing detailed, well-defined instructions.

It’s a bit like the dream of amateur cooks: having a robot that can look at what’s in the fridge and cupboard and prepare a complete lunch all by itself, after we vaguely explain what we want.

But it is also the dream of the amateur vibe coders, those who would like to be able to ask the AI to program an application “like this and that,” go out for a pizza, and find everything ready upon return, including the porting for major platforms and an e-commerce site to sell it.

Putting Antigravity to the test

So far, all these experiments haven’t exactly looked great but, as Sean Connery teaches us, never say never. So let’s see how the agentic functions integrated into Google Antigravity work in practice.

To test them, I asked the program to perform a few specific tasks, ranging from simple things to a particularly complex task. I tried to to leave it free to decide what to do and to intervene only when it was truly necessary. Although I chose tasks that were relevant to my own research, I believe the results are significant nonetheless.

Here is how it went.

Before starting

Before starting, I pretended that I was using Antigravity for the first time, and deleted all the files generated by the application with AppCleaner. I ran the onboarding process again, choosing to Start fresh without importing configurations from VS Code or Windsurf, and to use the Review driven development mode without modifying the default options.

I didn’t install any extensions, because I prefer to decide for myself what I need.

One more thing: the version of Antigravity I used to write this post is 1.11.17. However, given the speed of development, it’s possible that some aspects of the interface and how the program operates may have changed by the time this post is published.

Task #1: Extracting data from images

Let’s start with something simple, yet very important when dealing with old scientific papers: extracting data from images. My goal was to verify whether it is possible to instruct the Antigravity AI to extract data on its own from the figures in this paper, which has recently been published. I am not at all proud of it (to put it mildly), but the referees surprisingly accepted it almost without a word.

Today, the reproducibility of results has become a key principle and it is normal to share all the data from a scientific paper on public repositories like Zenodo, OSF, Dataverse or maybe GitHub. Until a few years ago, however, the original data were essentially only accessible through the figures in papers. This is precisely why it is important to be able to extract them from images.

Although there are many programs dedicated to extracting data from figures (like this, this or this), they require user guidance – at the very least to define the position of the X and Y axes and the coordinate limits. Some programs can work automatically, but only if they deal with well-defined types of images. ³

Before starting, I created a new directory in which to save the graphs that I had downloaded from the paper’s web page, just as a colleague who wanted to repeat my experiment would do. While I was at it, I also included the PDF file of the paper, which I will need later.

NOTE. All of the questions listed below have been copied without correcting typos and clumsy syntax, due (in part) to the excitement of seeing the results quickly. However, these errors are useful because they demonstrate that these systems can understand our requests even when the form is far from perfect.

I chose to use Gemini 3 Pro (High), which is currently the most powerful model in Antigravity. First, I asked it to orient itself within the directory content.

Prompt

In the current directory you will find a pdf file, a couple of folders and some inages in png or webp format. Is all this right?

Gemini thinks for a couple of seconds and then confirms that everything is correct. Very well, then

Prompt

Now open the file containing "Fig1" in the filename. This is an histogram showing the concentration of several chemical species in two kinds of Shungite, type Z (darker bars) and type B (lighter bars). Could you extract the values of concentration from the images? Please produce a table with the name of each chemical species and the associated concentrations for the Type Z and Type B material. Export the table as a csv file named "gemini-fig1.csv" and as a markdown file "gemini-fig1.md"

This is the image that Gemini had to deal with

Despite me being deliberately vague about the file name, Gemini can find it without problems and, after about twenty seconds, produces the two requested files. The table generated by Gemini is

Chemical Species	Type Z (Concentration %)	Type B (Concentration %)
SiO2	41	52
C	33	16
Al2O3	11	16
Fe2O3	5	3
FeO	3	2
TiO2	0.2	1
MnO	0.1	0.2
S	1.2	0.5
MgO	0.5	1.5
Na2O	1.5	1.2
CaO	0.5	2
K2O	1	2
H2O	2	1.5
minor elements	0.5	0.5

Comparing it with the real table with the measured values of concentration

Species	Type_Z	Type_B
SiO2	40.8	52
C	33.4	16.3
Al2O3	10.6	15.8
Fe2O3	4.7	3.2
FeO	3.5	1.9
TiO2	0.4	0.9
MnO	0.14	0.12
S	1.1	0.6
MgO	0.3	1.6
Na2O	1.6	1.2
CaO	0.4	2.3
K2O	1	2.2
H2O	1.6	1.4
Other	0.46	0.48

it is immediately apparent that all the values extracted from the figure are very close to the real values, with minimal approximations of less than 0.5%.

I am truly impressed by the result: Antigravity did everything in a few seconds without any intervention from me other than preparing the files and writing the prompt. While normal chatbots like ChatGPT or Claude can do similar things, Antigravity allows us to work directly on our computer with our files, without having to transfer anything back and forth via a web interface.

Task completed with full marks.

Task #2: Replication of graphs

For reasons that are not relevant here, I contributed very little – and mostly critically – to the writing of the paper mentioned in Task #1. Specifically, I didn’t prepare the graphs as usual. Instead, they were created by a colleague using Matlab, a scientific computing environment much loved by engineers. They are right to love it, because with Matlab you can perform very complicated calculations with little effort. However, producing high-quality graphs is certainly not one of its strengths

Let’s see if I can get Gemini 3 Pro to recreate the histogram from Task #1 using the ggplot2 library in R.

Prompt

Now generate the R code to recreate the same graph, using ggplot2 and whenever possible the functions available in the tidyverse.

After a while, the script is ready and is saved automatically in the project directory. I give it a quick look and it seems fine. Thus, I open the integrated terminal in Antigravity and run the script as suggested.

Rscript recreate_fig1.R

Apart from inverted colors, the figure is identical to the original.

I want to be clear on this point: I didn’t touch a single thing of the code generated in Antigravity by Gemini, and I won’t do so later, either. Yet Gemini manages to recreate an almost perfect copy of the original in R, reading the data in the figure and recognizing all the surrounding elements of the graph, such as the X and Y axis labels, the numerical scales, or the legend.

I know R well enough and could have achieved the same result in a short time, but there is no doubt that, even in cases like this, Antigravity can be a valuable help for those who don’t know programming well.

However, I am a hard guy to please and I ask Gemini to invert the colors

Prompt

Sorry, but the colors are inverted. Type Z is light grey and Type B is dark grey. Please switch the colors so that they are identical to the original. Save the new R code as `Rscript recreate_fig1-1.R`

I run the new script and now the colors are correct. I am pleased to note that the name of the generated png file has also been updated, making it easier to compare the different files produced by Gemini.

Once again, I am very impressed. Gemini did everything perfectly and I didn’t have to correct a single line of code.

It was undoubtedly an easy job, but the result is still very interesting. This is especially true given that we are talking about a specialised language like R, which doesn’t have the same volume of training examples as more popular languages like Python or JavaScript.

It seems that also this task has also been completed with full marks.

Task #3: Generation of new graphs

Gemini was able to successfully recreate the histogram from the paper, but I I would like to check whether there are any more effective alternative representations.

I pass the ball back to Gemini 3 Pro, which comes up with two interesting ideas: a Lollipop chart and a Dumbbell plot, which however don’t fully satisfy me. I try to get it to make some changes, Gemini always performs flawlessly but the result doesn’t improve.

In the end, the most balanced graph is the usual histogram, this time with the X and Y axes swapped and very different colors for the two types of material.

Since I am hard to please, I choose a much more complicated figure from the same paper

and I ask Gemini to repeat the process of generating equivalent graphs using R and ggplot2. Gemini gets straight to work, understanding by itself that the concentration of the elements at day 0 applies to both types of material, a fact that isn’t trivial to understand just by looking at the graph.

Answer

For Day 0 ("untreated sample"), I assigned the same concentration value to both Type Z and Type B in the dataset. This format suggests that both treatments start from the same baseline, which will make plotting lines easier in R.

I’ll spare you the details. Gemini easily produces several different types of data visualisations from the image above, such as a heatmap or a Sankey plot. While the graphs weren’t 100% satisfactory, they demonstrate that Gemini can perform the tasks required by demanding users such as myself.

What truly stuns me is that Gemini understands by itself that, when I asks it to arrange the graphs in two columns, one for each material studied, I actually want what is called a facet in R jargon. This may seem like a small thing, but it means that these more complex representations become accessible even to those who know what they want but cannot express it precisely.

It must be said, however, that as convenient (and even fun) as it is to ask and watch Gemini work, when you get to the finer modifications, you lose much more time writing questions and waiting for answers than working directly on the code. This is a detail to keep in mind.

However, it must be said that, although it is convenient and even fun to ask questions and observe Gemini in action, when it comes to the finer modifications one ends up spending much more time writing questions and waiting for answers than working directly on the code. This is an important detail to consider.

Let’s say that this task deserves a passing grade.

Task #4: Interaction with code and operating system

Now, let’s see if the Gemini 3 Pro integrated into Antigravity can perform basic file and folder management operations. Although I ran all the tests on macOS, the examples should also apply to various incarnations of Linux and BSD Unix.

First, I asked it to tidy up the files generated so far, moving the R scripts to the code directory, the data files to data, and the generated graphs to output. After thinking about it for a moment, Gemini 3 Pro creates a simple shell script to execute the request. It even made an error, noticed it, and asked for authorization to correct it.

First, I ask it to tidy up the files generated so far by moving the R scripts to the ‘code’ directory, the data files to ‘data’, and the produced graphs to ‘output’. After thinking about it for a moment, Gemini 3 Pro created a simple shell script to perform the task. It makes an error, notices it and asks for authorisation to correct it. Very, very good.

But what I like even more is that it automatically updates all the previously written code with the new file paths.

I then ask it to add my usual preamble to each R script, which creates a well-defined R environment. I give it an example from one of my old scripts, but otherwise allow it to do whatever it thinks is best. Gemini does everything perfectly, again updating all the file paths created so far. Truly impressive!

Gemini also handles perfectly the conversion of tabs from two spaces to four spaces, as I like it. In fact, it even recognises the need to do this without introducing formatting errors into the code. Better than a linter.

Lastly, I move on to try code_versioning_ with git which is always useful when a project starts to become slightly complicated.

Prompt

Could you now initialize a local `git` repository for this project? Versioning is very useful as soon as a project starts to become complicated.

Everything works wonderfully; Gemini creates the requested repository, makes the initial commit, and also adds a sensible .gitignore file. Obviously, I can query the repository status or perform all the usual git operations I am used to doing from the Terminal.

While I am a bit afraid to allow an agentic system to perform these operations on my Mac, I must admit that the result is perfect.

What I wrote at the end of the previous task still holds true: a user who is familiar with git commands can work much faster in the Terminal than by asking Gemini. However, for the average researcher (or general user) who is unfamiliar with the Terminal and versioning systems, using an agentic system like this can be an excellent way to interact with code at a low level without having to study large amounts of pages of documentation.

In any case, another task passed with full marks.

Task #5: Statistical data analysis

I won’t make this long, because Antigravity/Gemini 3 Pro is a bit weak on statistical analysis.

If I let it do whatever it wants, it comes up with nonsense, such as creating correlation matrices between concentrations of different heavy metals or trying to compare “differences of effectiveness” between the two materials. Admittedly, it’s not an easy task, but it shows – should it still be necessary to demonstrate it – that these intelligent systems are very useful when given precise instructions, but struggle to work independently when the user doesn’t have a clear idea of what they want to achieve.

In fact, once I explain properly what kind of data I am dealing with and what I want to achieve:

Prompt

The two types of shungite, type Z and type B, are different materials and they are used independently. In other words, the experiments made using type Z material is completely independent from the experiment with type B, so the two materials cannot be directly compared. This means that the stat_difference_boxplot has little sense, and the same is true for the correlation matrix which photographs a single day (I guess day 0 for only one type of material), while we are interested to time series. Therefore you should try to use some statistical analysis able to deal with time series.

Gemini thinks about it for a while, makes some mistakes but manages to correct them on its own, and eventually comes up with a small model showing how type Z material absorbs heavy metals more rapidly than type B material. If there were more data available, it would make sense to reflect a bit on the model, but for now, it’s enough.

Gemini thinks about it for a while, makes some mistakes, but corrects them by itself, and eventually comes up with a small model showing that type Z material absorbs heavy metals more rapidly than type B material. If there were more data available, it would be worth pondering a bit over the model, but for now, this is more than enough.

Hard to give a grade here, let’s say unclassified.

Task #6: Extracting tables from PDF files

Here we enter into hostile territory. Automatically extracting the content of tables in PDF files may seem trivial, but it is a subject that has puzzled hundreds of researchers, myself included. The main problem is that the PDF format is designed to manage the visual aspect of the page, but knows nothing about its content.

For my tests, I asked Antigravity to open the PDF file of one of the Hydrological Yearbooks of the Apulia Region, in southern Italy, and extract the minimum and maximum temperature data measured at a few meteorological stations in Apulia.

While daily data is now available online, the PDF Yearbooks still remain a fundamental resource as they contain temperature and precipitation data from approximately 150 meteorological stations since 1921. This allows us to analyze how the region’s climate has changed over the last century.

Years ago, I solved the problem of extracting data from these PDF files through a combination of R and AWK scripts. However, the procedure is long and complex, as many inconsistencies in the tables must be corrected manually.⁴ In the end, extracting data for one year takes a couple of hours of careful work -— not to bad given the complexity of the task – but it would be very useful to delegate this task to an AI.

Therefore, I try to have Gemini 3 Pro do it, writing a long prompt where I explain exactly what to do

Prompt

Open annale2013.pdf and go to page 6, where you will find a pair of data tables with measured precipitations [sic! sarebbe dovuto essere “temperatures”] for two weather stations. The data is arranged in pairs of columns, and each pair corresponds to a month, G for gennaio (january), F for febbraio (february), etc,. until D or dicembre (december).

As for the pairs, the first column is the minimum temperature and the second column is the maximum temperature.

Each row represents a different day.

At the end of each table there are some summary data, Medie, Med.mens. and Med.norm that you can skip.

Missing data can be marked by either one or more > or < signs, or by = or be simply blank. In some tables there are extraneuous signs that you can skip outright.
Read the table and generate two different csv files, one for the maximum temperature and one for the minimum temperature, following this example

Date,Altamura,Andretta
    2007-01-01,13.4, 7.7,
    2007-01-02,15.7, 9.7,
    2007-01-03, 7.1, 2.7,
    2007-01-04, 9.5, 7.0,

The header contains the date in ISO format, YYYY-MM-DD, and the name of the weather station which is written in bold at the top of each table, just under the months. All other information in thsi area, eg., (Te), Bacino etc. is not useful and can be skipped.

Gemini tries repeatedly to solve the problem using Python, but its scripts produce a lot of errors and skip several days of valid data. After all, it’s not an easy problem, I spent months on it myself, so I give it a little help.

However, at this point Gemini throws an error and it is impossible to make any further progress.

The best option would be to start from scratch, but in the meantime I have reached the quota limit for Gemini 3 Pro (High) and would have to wait several days to continue.

That is clearly not option, so I decide to switch model and try Gemini 3 Flash, which everyone is talking about right now. Gemini 3 Flash starts working and proposes a plan that seems sensible, but that in practice produces a jumbled mess due to the presence of extraneous characters and unclear formatting, as Gemini 3 Flash sadly admits.

I therefore recommend using the pdftools library in R. I have used it myself and it produces far better results than similar Python tools. Finally, bingo! Gemini 3 Flash produces a data file that is 100% correct.

To be truly useful I should have it repeat the process for all stations and for several different years, but for now I’m satisfied, given that I don’t want to waste all my quota on this task. In any case, the result achieved with Gemini 3 Flash is truly promising and deserves further exploration.

On the other hand, it’s impossible to achieve anything worthwhile with Claude Sonnet 4.5 (Thinking). After trying again and again, I reach the quota limit for this model and have to stop.

What about grading this task? Gemini 3 Flash achieves the maximum score, while Gemini 3 Pro should be retested under the same conditions as the smaller model. Lasty, Claude Sonnet 4.5 is unclassified.

Task #7: Programming a microcontroller

Another area in which Google Antigravity’s agentic functions could prove very interesting is the programming of microcontrollers such as Arduino, Raspberry Pi Pico, or ESP32. There are literally mountains of these little gadgets, and it’s difficult to navigate the many different models as well as the thousands of sensors and modules that can be connected to them.

In this specific case, an AI system capable of quickly producing working code would be extremely useful.

For my tests, I decide to use a Nicla Vision, which is essentially an Arduino with a built-in camera. The Nicla Vision is a true gem. It’s not cheap, but it’s worth every penny. However, it is also far less common than standard microcontrollers. If Antigravity can program it correctly, it will certainly succeed with normal Arduinos, Pi Picos, or ESP32s.

I switch back to using Gemini 3 Flash and ask if it knows the Nicla Vision. I also provide it with a link to the product webpage to help it locate the device. Gemini confirms that it knows exactly what I am talking about, and we can begin.

To program these devices, I have only ever used the Arduino IDE and Thonny, and I don’t know if Gemini can manage the microcontroller directly from the editor. When I ask, Gemini replies with a very simple command

% ls /dev/tty.usbmodem* /dev/cu.usbmodem* 2>/dev/null || echo "No usbmodem devices found"

that allows checking if the Nicla Vision is connected to the Mac. Once it has found it, it checks whether the Python libraries required for communication with the microcontroller are installed. Since they are not, it proposes installing them. It also rightly gives me the option of installing them globally or in a virtual environment, and needless to say, I choose the latter option.

Gemini also prepares a short test script that makes the LED blink (the classic “Hello World” of the IoT world). When I confirm that everything works, it proudly proclaims:

Answer

I'm ready to start writing more complex code for your project. What would you like to build first?

Up to now, Gemini has done nothing than I could not have done myself with Homebrew and Conda. However, I would have had to consult pages and pages of scattered web documentation. Here, instead, I managed to configure everything in just a few minutes and I also learnt many useful things.

Since Gemini was so keen to be useful, I asked it to write a small program that uses the Nicla Vision to take photos at set intervals and send them to the Mac via Wi-Fi. The result? Everything worked on the first try.

And Gemini didn’t even get offended when I told it straight out that I didn’t trust it with my Wi-Fi password. In fact, it suggested a more secure alternative. But I am distrustful by nature, so in the end I used my iPhone’s hotspot with a disposable password.

In conclusion, even the last task is passed with full marks.

Leaving a trace

One truly annoying thing about Antigravity is that it doesn’t have a function to export a complete log of what you do, with the questions asked and the model’s answers, and maybe even its thoughts.

Edit. I was wrong, the keyboard shortcut CMD (⌘)-E opens the Agent Manager, a separate Antigravity window that, among other things, lets you view the entire history of what Antigravity has done, including its thoughts. The problem is that there isn’t a specific menu item for the Agent Manager (or at least, I haven’t found one), and the keyboard shortcut is only shown when the program starts.

Edit #2. The Agent Manager can also be opened directly from Antigravity’s toolbar: the corresponding entry is located right next to the icons that allow to change the application layout and perform searches. I don’t know why I didn’t notice it earlier, but in my partial defence I should point out that all the other toolbar commands are represented by icons. For this reason it isn’t immediately clear that this entry is a command rather than just a plain text string, just like the name of the application sitting in the center of the toolbar.

Anyway, after every operation, Antigravity lets me read a detailed Walkthrough of what it did. Right-clicking on the relevant Tab,

I see that it is possible to reveal the file in the Finder. This opens a folder with a large number of Markdown files, all having standard names such as implementation_plan, task, or walkthrough followed by the resolved suffix and a progressive number

that provide the history of everything I do with the agentic system.

Whenever I request something from one of the integrated agents, Antigravity generates three files containing: (1) what it must do, task; (2) the work plan, implementation_plan; and (3) a summary of what it did, walkthrough. At first glance, it’s not easy to relate these files to each other, but the mechanism deserves a closer inspection. For the record, all the files in question are in a directory inside ~/.gemini/antigravity/brain/, but the main ~/.gemini/antigravity/ directory contains many other directories with configuration files, generated code, and more.

Conclusions

It’s clear that I enjoyed using Antigravity. In some cases, those who know how to program risks being slowed down rather than helped, but in general, and in particular for those familiar with Word, Excel and little else, Antigravity’s agentic functions can prove to be a truly valuable help.

In my life as a non-professional programmer, I went from writing code while consulting huge books of documentation to searching for answers on StackOverflow. In my view, Antigravity’s agentic functions are like StackOverflow on steroids: not only do they provide answers to our questions, they also interpret and reason about them, proposing solutions almost autonomously.

But, just as on Stack Overflow, you should always rely on your own knowledge and experience to distinguish useful, working answers from those that are irrelevant.

However, please let’s not talk about vibe coding, i.e. the ability to ask the program to perform a given task and then go for a walk while Antigravity does everything alone! ⁵ As the examples show, if you are not very precise in explaining what you want and you don’t check step-by-step what Antigravity proposes to do, you risk the entire process failing or producing wrong results.

Just like a thesis or PhD student, or a young colleague, Antigravity can be a great help if you know what you want and how to achieve it, and can explain it clearly. However, making it come up with its own ideas – I don’t mean original ideas, just sensible ones – is still just science fiction for now. Or marketing.

The mere fact that Google was using code produced by a direct competitor for one of its development tools seemed, shall we say, rather unusual to me. ↩︎
It is true that TextMate and BBEdit are not true IDEs (in particular TextMate), but the difference in size is still impressive. ↩︎
Several years ago, I developed a C, er Python program that could do that automatically, but only with images from a particular type of digital oscilloscope. ↩︎
The imagination of those who compiled the tables deserves an award. ↩︎
Even a very busy programming guru like Linus Torvalds uses vibe coding, but only for his own projects. In any case, he only uses it fo for his little toys, certainly not for developing the Linux kernel. ↩︎

A year of melabit.com

Wed, 31 Dec 2025 06:00:00 +0000

2025 was a turning point for this little blog. Leaving the comfort zone of Wordpress.com was neither easy nor painless, especially when I discovered that once the site was online, Jekyll was slow, too slow to be usable.

Thankfully, Hugo saved the day, although there are still many details to be ironed out, first and foremost the website’s graphic design.

– Image generated by Google Gemini.

Managing posts in two different languages is not easy, but it is worth it, as posts in English allow to reach a pool of users that would be unimaginable if I only wrote in Italian.

The main concern with the new site is the near absence of comments on posts. I don’t know if it’s because they’re too complicated, too long, or both. The fact is that the lack of comments is really worrying. And this is despite the fact that there are a good number of visitors and that on average 5% of them spend 15 minutes or more on the site. Maybe in the end they’re too exhausted to comment, who knows!

Needless to say, I never use AI tools to write the posts. At most, I use them to look up a few technical terms when I can’t remember the Italian equivalent (for instance, I always forget that Tab in Italian is Scheda, not Linguetta). Sometimes I try to use AI to improve the flow of a few sentences, but it’s almost always a waste of time. In the end, the text sounds so flat that it’s better not to write it at all.

However, I admit that I use AI for the initial translations. I need it mainly to save typing time, even though it then takes quite a while to refine the result and make the translation more fluid and natural.

I also often use AI to generate the images at the top of the posts. In this case, I have no choice. While I’m not bad at writing, I’ve always been second to last in the class when it comes to drawing and graphics, and only because the last one was really terrible. So I’m doing you a favor. But even with Google’s much-celebrated Nano Banana, it took a lot of effort to convince it to generate the image for this post, with the right text, the real homepage, and so on. Anyone who says that Nano Banana is so smart that it understands what you want right away is telling you lies.

If all goes well, 2026 will bring some new developments. I’m not sure in what order, but revising the graphic theme is definitely at the top of the list.

Stay tuned! In the meantime, best wishes for 2026. May it be a year full of good things and happiness for everyone!

Photocopied!

Mon, 15 Dec 2025 18:00:00 +0000

The video above is the official presentation of Google Antigravity, an IDE (Integrated Development Environment) that is not just a simple IDE but is “a new way of working for this next era of agentic intelligence”. I haven’t yet figured out what that truly means, but it surely sounds very smart and up‑to‑date.

So let’s see what this “new way of working” is, in which the agents “help you experience liftoff”. An expression that back in the day used to mean something quite different.

I download the latest version of Google Antigravity (1.11.17), which once installed takes up a whopping 700 MB. Once I get past the usual onboarding screens and log in with my Gmail account, here’s what comes up

It’s basically VS Code from Microsoft, plus the agentic tool Antigravity, whose exact purpose I still don’t know and, more importantly, whether it’s useful.

After all, that’s essentially what they told me during the onboarding process, when I was presented with a screen offering to either set up the editor from scratch or import settings from VS Code. Or Windsurf.

Windsurf?

Yes, Windsurf, an editor derived from Cursor,¹ which in turn was derived from the always-present VS Code.

The similarity (to use a euphemism) becomes obvious when you place them side by side, with Antigravity on the left and Windsurf on the right.

Identical.

In short, the revolutionary IDE, the “new way of working for this upcoming era of agentic intelligence” that “helps you liftoff”, is nothing more than a clone of an editor that was already a clone of another editor that was itself a clone…

Digging a little deeper it is easy to learn that Google spent $2.4 billion to acquire the Windsurf code and hire its two founders, Varun Mohan and Douglas Chen, along with a handful of the company’s developers.² However, fearing antitrust intervention, Google avoided buying the actual product or the brand, so that Windsurf continues to exist and be developed independently, trying to repeat the David versus Goliath story.

It is a more or less as if, in the 1980s, Microsoft had hired Steve Jobs and Steve Wozniak, maybe also Bill Atkinson, Andy Hertzfeld, and Susan Kare, taking the original Macintosh code with them. Then re‑releasing it a few months later as Windows 1.0. In the meantime, Apple would have continued to develop the same code for the original Mac.

I get the feeling that the Google team used something else to liftoff.

But putting the (silly) jokes aside, are the agents in Antigravity actually useful during development? I’m not sure myself, and that’s what we’ll find out live next time.

If you’re interested in the controversy that followed the latest price hikes at Cursor, you can read about it here. ↩︎
The post is behind a paywall, but you can read it freely here. ↩︎

macOS Tahoe: let's free the icons!

Mon, 24 Nov 2025 18:00:00 +0000

It is not just a matter of disk icons. As soon as I saw what Tahoe had done to the icons of many applications installed on my Mac, I decided I had to do something to restore the original look of the icons.

I tried several times, using Apple’s home‑automation tools, Automator and Shortcuts, but nothing worked and there was always some function missing. Or maybe I’m just not very good at using them.

Then I discovered fileicon, a library available on Homebrew that lets you programmatically modify file and folder icons. With that, the problem was practically solved.

– Source: Hennie Stander on Unsplash.

The squircle jail

With Tahoe Apple introduced a new icon format that now has to conform to the default shape of a squircle, a cross between a square and a circle (or a superellipse, for those who enjoy mathematics).

Apple redesigned its application icons to fit the new format and the aesthetic standards of Liquid Glass, although the final effect is often quite debatable. Even John Gruber doesn’t spare criticism of this aspect, going so far as to call the designer of the Automator icon a hack who never should have even gotten a job working at Apple (and how can one say he’s wrong?).

The problem, however, isn’t just that many Apple application icons lost meaning or are outright ugly, but also that many third‑party application icons don’t fit properly into the jail represented by the squircle.

It happens with all those applications that have beatifully-crafted icons, such as Audio Hijack, BBEdit, Alfred, Amphetamine, VLC, NValt, Gemini 2, HandBrake, Keyboard Maestro and so on.

These are all well-known applications built by medium-to-large teams. Yet overe these months they haven’t deemed it necessary (or useful) to adapt their gorgeous icons to the new standard imposed by Tahoe.

And imagine if the smaller developers, or those building cross‑platform applications where a unique, recognizable look is essential, have done it either.

What happens in those cases? Tahoe automatically shrinks the icons of these applications and encloses them within the squircle. Moreover, almost as if to remind developers to hurry up and comply with Cupertino’s dictates, it places these icons on a gray background which calling ugly would be an understatement.

In the first beta of Tahoe the final result was simply hawful, as you can see in the images from my first article on Tahoe. Moreover, this brutal treatment made some icons almost invisible (Tunnelblick, QGIS, OpenMV IDE, Thonny).

In the public version of Tahoe, released in September, and in the subsequent updates, Apple toned down some of the transparency excesses of Liquid Glass and also lightened the gray background of the icons that refused to fit within the squircle.

The final effect is undoubtedly better.¹ However, the gray‑bordered icons are still ugly and much smaller than they could (and should) be.

Can we do something to bring back the look they had before the Tahoe treatment?

Let’s Free the Icons

Obviously the answer is yes, otherwise I wouldn’t have written this post.

The manual method is described very well here and requires right‑clicking the application icon, selecting Get Info and replacing the icon thumbnail with the one that lives inside the application bundle itself.

To find it, right‑click the application icon again, choose Show Package Contents, click on the Contents folder, then on Resources and look for the file with the .icns extension (keeping in mind that some applications may contain more than one such file) and drag it onto the thumbnail in the Get Info window.

It sounds complicated but, with a bit of practice, it becomes fairly quick. This manual method works fine if you only have a few applications to fix. But if, as in my case, there are more than 20 applications, it quickly becomes tedious and error-prone. And, as if that weren’t enough, you’ll probably have to repeat the process every time the application is updated.

Better to let your Mac do everything automatically. And that’s where IconLib comes in.

IconLib

IconLib is a simple Bash script that automates the whole process, relying on the fileicon library to actually perform the icon modification. All you have to do is provide it with a file containing the list of applications to update – and sometimes the name of the .icns file too, because, darn it!, many developers use icon filenames that have nothing to do with the application name and often bundle multiple .icns files inside the application bundle – and it does the rest.

If you’re not happy with the result, you can run the script again with the -u switch (for undo), restoring the Tahoe icons.

You can also run IconLib on a list of applications, and then later edit the list to restore the icons for only the selected applications, leaving the others in their pre-Tahoe state.

All the details are in the README file of the GitHub repository and I won’t repeat them here. Instead I’ll just show how the icons look after fixing them with IconLib.

Even though the old icons don’t follow the stylistic dictates of the squircle, the richer, less constrained look and the absence of the gray background make me prefer them, at least until developers roll out new icons better suited for Tahoe.

Bare Bones Software just did it for BBEdit. The fact that such a major software house took so long indicates it’s no easy task, or that developers hoped (in vain) for months that Apple would backtrack. And if BBEdit took that long, it’s hard to imagine other cross‑platform or niche applications adapting quickly.

Conclusions

IconLib is not a must‑have program at all and it serves an admittedly narrow audience.

First of all, it is useful for people like me, who have many programs installed on their Macs, often produced by indie developers or by specialist teams that lack the time, desire, or expertise to deal with subtle graphics issues (think, for example, of Tunnelblick, for managing VPNs, Thonny, a must‑have for those who program microcontrollers in Python, or JASP, one of the best statistical programs for those who know little about statistics).

It also helps anyone who is dissatisfied with the jail that Tahoe enforces around the formerly magnificent icons of many applications.

Finally, it assists those who think Apple is overdoing this trend in macOS, which increasingly feels like an offshoot of iOS rather than a standalone system deserving its own life.

And lastly, it serves those who think Apple is going too far with this drift in macOS, which increasingly seems more like a by-product of iOS than an operating system worth its own independent existence.

While they were at it, couldn’t they have used a white background? ↩︎

macOS Tahoe, again

Mon, 10 Nov 2025 18:00:00 +0000

After less than two months since the official release, Tahoe seems poised to become another one of those macOS versions to be forgotten, like Lion, Mavericks, Sierra, Catalina, or Ventura.

Aside from Liquid Glass, which I’ll discuss in a moment, what does Tahoe have that’s memorable? There’s the telephone‑call filter, which actually belongs more to iOS than macOS and still has many limitations, and there are also improvements to Spotlight search. But is it really worth upgrading an operating system just for that?¹

Liquid Glass should be the real novelty of macOS 26 Tahoe, but Macworld first compared it to Vista and then declared it dead in the cradle. If Macworld says so – not PCWorld, not Linux Pro -— there’s definitely something to be concerned about!

Moreover, Liquid Glass went wrong from the very beginning, when some joker thought of inverting the colors of the Finder icon. Without any particular reason, just for sake of change.

The criticism was so destructive that Apple had to backtrack quickly, restoring the historic design of the Finder icon, the one we’ve known for thirty years and that is one of macOS’s distinctive marks.

Haowever, when it came to disk icons Apple managed to do even worse. In the very early betas of Tahoe the disk icons were identical to the ones we’ve been used to for years: the image of a mechanical hard‑disk for internal drives and a rounded orange rectangular prism for external drives. Very skeuomorphic, but also very clear and even pleasant to look at, with all those little screws, colored LEDs, and even a label warning us not to open the disk.

With the fifth beta of Tahoe, Apple throws the old hard‑disk icon into the trash and replaces it with a more stylized image that should represent the SSD installed in all Macs for years.² While it’s at it, it also freshens up the other disk icons (external, network, and removable) and the result is shown below, where the top row displays the disk icons up to Sequoia and the earliest Tahoe betas, while the bottom row shows the updated icons.

– Source: Ars Technica.

Soon after, the internal‑disk icon loses all front elements, that perhaps were meant to represent ventilation slots or activity LEDs, and becomes as minimal as the others.

Admittedly, the new icons are bland, having lost all detail in favour of greater simplicity, just as has happened to the rest of the graphical interface built around Liquid Glass. But so far that’s fine.

What’s incomprehensible is why the icons were redesigned to appear narrower in the front and wider in the back, defying the laws of perspective and how we’ve been accustomed to seeing them up to Sequoia. It’s merely an optical illusion; in reality (I checked) the icons have perfectly parallel sides, but the play of light and shadow makes them look odd and out of place.

The effect worsens when the icons are placed side-by-side, because the differing reflections make the gray internal‑disk icon look more natural and less distorted compared to the external units.

Now, I can understand the need to adopt a homogeneous and well-defined graphic language, but wasn’t it possible to design icons that looked more natural? Susan Kare managed it with just 32×32 pixels, how can we think that today’s Apple designers, who today have immense fields of pixels at their disposal, can’t do the same?

If Cupertino can’t even produce a convincing disk icon, how can we trust that Tahoe and Liquid Glass are serious projects?

The annual macOS update cycle is good for marketing, but from a technical point of view it makes very little sense. Not only because it’s hard to invent truly novel features for each annual release of macOS, but also because this relentless quest for novelty distracts from equally important activities such as fixing bugs in the current version and optimizing system performance. ↩︎
Actually, the new internal‑disk icon has nothing to do with an actual internal SSD image, but we won’t be too pedantic about it. ↩︎

Is it still worth learning languages with Duolingo?

Thu, 23 Oct 2025 18:00:00 +0000

Learning a language is hard work: you have to learn vocabulary, study grammar, repeat endlessly. And then, once you know a bit of the language, you have to start reading, listening, speaking with others. In short, it’s no joke.

In the past it was even worse. We studied from massive tomes full of rules, made especially to make you hate the language. My high‑school English book dedicated fifteen pages just to the use of the definite article “the”. I never read a single line of that book.

Luckily, there were courses with discs or tapes. In middle school I learned English with one of those, a Reader’s Digest course borrowed from an uncle. It had to be good, because in the end I could read and speak English reasonably well.

– Source: subito.it.

I didn’t do it for noble reasons, but only because I wanted to preview the original Spider‑Man and Fantastic Four comics that I found, with great effort, at a downtown newsstand.

Old times! Today there is a mountain of apps that claim to teach languages, from the classic ones like English, French or Spanish, to more exotic languages such as Finnish, Chinese, Japanese or Korean, and even niche ones like Navajo, Hawaiian or, yes, Klingon.

The most famous app is undoubtedly Duolingo, “The free, effective, and fun method to learn languages!” which has dethroned the venerable Rosetta Stone. But a quick look at the iOS App Store (or Google Play for Android users) shows dozens of alternatives, from Babbel to Lingvist, to Busuu, Memrise, Moondly, Mosalingua, …

But is it really possible to learn a language by spending a few minutes a day on a phone? And more importantly, does it still make sense to do it with Duolingo?

Four Years with Duolingo

I used Duolingo every day for four straight years to study German. I think I learned something, because I passed the A2 level exam. But, to be honest, if I started today I wouldn’t do it again.

Some lights

There’s no doubt Duolingo is cute, fun, and a pleasant daily habit. Its biggest advantage is that it doesn’t focus on grammar for its own sake, but teaches it through practical language use, putting grammatical rules in the background. In general it works, although occasionally it would be useful to dive deeper into more complex rules.

Another plus is that you can decide how much time to devote to study. I always spent little, say 10-15 minutes a day, so after four years I’m still at the beginning of level B1, and at this pace it would take another two years to finish it.¹

Finally, there’s the game-like nature of the app. As I said, Duolingo is enjoyable and even fun, which is a strong incentive to open the app every day. The challenge of maintaining your streak of consecutive lessons also helps to ensure that you study regularly.

And many shadows

But its game-like nature is also one of Duolingo’s biggest flaws. If you overdo it and get too caught up in the XP points competition with other users, a study session that should be relaxed turns into a race to collect as many points as possible and climb the global leaderboard, just like a video game.

I made that mistake myself. I used tricks and hacks of every kind, managing to reach the third place in the Diamond League, the highest and most prestigious level.

Then I came to my senses and said enough is enough: I turned off my public profile and lose all contact with friends and (especially) with the competitions. Because doing that I wasn’t learning German, I was just playing. And indeed, from that moment on, things went much smoother.

The app isn’t that great: it sometimes crashes and loses lesson progress. Other times it fails to recognise words I just pronounced, yet moves forward and writes down answers I haven’t said yet. Occasionally an advertisement won’t close, and the only way to continue is to restart the app. No wonder the developers constantly update it, mostly to fix bugs.

A major learning issue is that you can’t go back during a lesson to review a previous exercise or recall a new word. It feels like reading a Kindle book where you can’t flip back to earlier pages. I understand developers want to prevent answer changes (but it would be easy to block), yet from an educational point of view this is a terrible choice.

And there’s the limited‑effort problem: learning is rather slow. If I’d taken a traditional course I would have reached B2 in two years; with Duolingo it took almost four. That can also be seen as an advantage, because without strong motivation it’s hard to dedicate a lot of time each day to learn a language (not just this one).

But the worst flaw of Duolingo is the continuous reshuffling of the course organization. Years ago there was a total overhaul of lesson structure, causing massive confusion and a flood of criticism.

These changes keep happening: the old 20 groups (Units) of 10 lessons each can suddenly become 40 groups of 5 lessons each. A month later they might become 30 groups of 8 lessons, or 60 of 4. These periodic changes are very annoying, like having to change routes every day because of roadworks.

Even worse, the reason behind these constant modifications isn’t clear. I get that developers want to improve the code, update the UI, add new features here and there. But Duolingo is a language course, not rocket science that evolves daily. Even if there were behind it sophisticated studies on the best way to teach a language (but is that really the case?), I doubt such research progresses so quickly that it requires continual course overhauls.

AI-First

A few months ago, following the current trend, Duolingo’s management put AI first, deciding to “replace the slow, manual content‑creation process with one based on artificial intelligence,” according to co‑founder and CEO Luis von Ahn.

He says it’s done out of duty, to “provide this content to our students as soon as possible”.

Hovewer, many users didn’t receive this well. Not only because, for a supposedly caring company, suddenly firing all its external collaborators is a pretty low move, ethically speaking and echoes what Elon Musk did with Twitter.

But also because it means that the production of high-quality content, perhaps slower, but also more accurate and reliable, has become secondary to the multiplication and expansion of courses and, consequently, to profit margins.

Unsurprisingly, right after the announcement the company more than doubled its course offering. And who cares if the translations are often done sloppily.

Money first, too

Cory Doctorow coined the term enshittification, described at great length in this recent Guardian article. At first, web platforms (or the applications derived from them) treat users with white gloves, pampering them to win their trust. Then they start favoring paying customers, to the detriment of everyone else. In the end, in order to monetize more and more, they also abuse paying customers, becoming nothing more than a giant pile of… shit.

A concrete example is Cursor, hailed as the ultimate AI‑assisted coding editor, which soon turned into an octopus that devours its own (paying) customers.

What happened to Duolingo mirrors this trajectory: initially the app was free to use and free of ads, and developers promised it would stay that way forever.

Later they politely introduced a small monthly fee for extra features, not essential for learning.

Then management took over, making life harder for users who clung to the free tier, stripping essential functions like lesson review or error correction, and locking them behind a paid tier.

Finally, a few months ago they replaced the old Hearts system with a new Energy system, represented by a battery icon that drains. A true, scientifically performed scam.²

Until July, before a lesson you had up to five Hearts. Each mistake cost a Heart, which could be regained by waiting a few hours, watching an ad or, until a couple of years ago, doing a “practice” lesson.³ This meant that users who made few mistakes could do virtually unlimited lessons, with only occasional ads.

With Energy this is no longer possible. Now you have 25 Energy units, and each response (not each mistake!) consumes one unit. After a streak of correct answers you regain a few units, but never too much. At the end, you can only do two flawless lessons before needing to recharge, three if you’re lucky. Energy recharges only via ads, not by reviewing!

And if you try to redo a whole lesson group to hit the Legendary checkpoint, each question costs two Energy units, leaving you with a near‑empty battery even without errors (see image below).

It’s crystal clear that this mechanism is a strong push toward the paid Super Duolingo and the newer Duolingo Max plans where, going against all the laws of physics, Energy (or the number of Hearts) is unlimited. Moreover, although paid plans do remove ads, even Super Duolingo still forces you to watch ads promoting Duolingo Max.

How Much Does Super Duolingo Cost?

Good question, given that it’s very difficult to find out how much Super Duolingo or Duolingo Max cost. If you go to the website, you’ll only find a very nice page but, unlike any other paid service, there are no prices listed.

The only way to find out is to start the free trial week. After onboarding and the first dull lesson, the screen reveals that Super Duolingo costs €10.99 per month. Paying annually drops it to €6.25 per month (€75 per year). The annual Family plan costs €8.84 per month (€106 per year) and can be shared with up to five other people.

Prices in dollars are similar: the base Super Duolingo plan costs $12.99/month, or $6.99/month if billed yearly (for a total of $83.88/year). The Family plan is $9.99/month (i.e $119.88/year).

Duolingo Max is even less transparent, but estimates put it around $30/month or $168/year. In my view, Duolingo Max isn’t worth it compared to Super Duolingo, it only adds a few extra feature: help on errors and the ability to chat with an artificial avatar, which feels far more awkward than talking to a real teacher (I have tried it myself).

At first glance, the annula Super Duolingo plan looks very affordable, and the Family plan is even more so, even if shared with only one other user. There are often discount offers as well. But price isn’t the only factor to consider.

Does Duolingo still make sense?

When Duolingo launched in 2011, the developers solemnly promised it would stay free and ad‑free, forever. Nothing lasts forever on the web, but it’s also true that these promises helped to build an active community of users who made Duolingo grow and flourish. Breaking these promises is like slapping in the face those who trusted you.

Duolingo was funded by the National Science Foundation, i.e., public money. The original idea relied on crowdsourcing: users learned a language for free while helping translate website content. All costs were covered by the sites that used the translations, under the banner that “Free education will truly change the world”.

In hindsight, it was a bizarre business model, given that in just a few years, AI-based translation systems have become so good that all that manual crowdsourced work that seemed so ingenious has become unnecessary.

The value of Duolingo lay mainly in its community of users, people who spread the app by word‑of‑mouth, contributed improvements, and kept the forum discussions lively. In short, that made it feel like a living thing rather than a mere product. Duolingo’s management is tossing all of that away in the name of a god called money. For example, the forums were brutally shut down because they offered free help to users, help that is now available only with the top‑tier plan, Duolingo Max.

But Duolingo hasn’t only betrayed the original spirit by becoming an also paid product. It has also rendered the much‑boasted free forever plan almost unusable, a plan that is now clogged with ads and has been stripped of many essential features that are available only in the Super and Max tiers.

I can perfectly understand that the creators of an app need money to run the infrastructure, pay developers, and so on. But then they have to choose. They can choose to offer a free app with fewer features than the paid one. Or they can offer a fully functional free app supported by advertising, while the paid version is ad‑free.

But they can’t do both at the same time: remove lots of useful language‑learning features and simultaneously fill the app with ads. And, as if that were not enough, let the quality of the courses drop.

Because there’s no doubt that, after all the changes of recent years, the quality of Duolingo’s language courses has also declined.

There’s less variety in the sentences you’re asked to translate, and the translations become increasingly literal, word‑for‑word, probably because there’s no longer any human inserting less mechanical alternatives into the solution database. The pool of words available in translation exercises is smaller, so you often end up merely arranging them in the correct order without having to choose between similar terms. Even the short stories are always the same; it’s been months since I was offered a new story to read.

The new course structure also contributes to this qualitative decay. When I started, four years ago, the courses were organized in a more traditional way, with lessons focused on clearly defined topics (Skills), ranging from basic concepts to food, animals, travel, and so on. The Skills were laid out in parallel tracks, so on any given day you could decide to do a lesson on plurals and another on food, and the next day focus on animals.

– Fonte: Duolingo Wiki.

Once you finished a Skill, a numeric crown icon gave a visual cue that you needed to revisit that Skill periodically, reinforcing your grasp of the topic.

All of that vanished in 2022 with the introduction of the Path in place of Skills. The Path arranges instruction linearly, forcing you to finish a given set of lessons (in purple in the image below) before moving on to the next set (light‑gray, indicating it’s still locked). Nothing prevents you from going back in the Path and repeating one or more lessons, But there’s also no incentive to do so, as there was with the old crown system.

The current linear Path resembles game levels, where you are required to finish a given level before unlocking the next. Clearly, this approach prioritises gamification over the pedagogical purpose of the app.

If that weren’t enough, the very lessons now feel far more mechanical and repetitive than before. I can’t say for certain whether a traditional course like the German one I’m following has already been poisoned by AI‑generated content, but that’s the impression I get. I dare not imagine what’s happening in the newer, less‑popular courses (and I was hoping to learn Hawaiian… 🤣).

Lastly, there’s the cost‑benefit ratio. In four years on Duolingo I completed the A1 and A2 levels, let’s say I spent roughly two years on each level. I always used the free plan because, making few mistakes, the five Hearts available were more than enough. And even when I occasionally lost all my Hearts, I could recover them with a quick review lesson, which never hurts.

Today I couldn’t do the same, unless I’m willing to waste a lot of time watching endless ads, which distracts and kills the desire to do a lesson.

The alternative would be to switch to the Super Duolingo plan, which in my usage scenario would mean spending about €150 for each new language level. That’s not a huge amount of money if you consider that a traditional online course can cost three or four times as much. But it’s a lot when you factor in that the aggressive gamification of recent years, combined with pervasive AI, has turned Duolingo from a program for learning languages into a language‑based game. And for a game like that, €150 is a high price to pay.

Conclusions

If learning a language is just a hobby or a distraction, using Duolingo for free can still work. But if you’re serious, paying for Super Duolingo makes little sense.

Luckily, there are several better alternatives, check out the reviews on this specialized site for more information. Personally, I would choose Rosetta Stone, which teaches languages intuitively, like a child learns its mother tongue.

Rosetta Stone does cost more than Super Duolingo, but it uses a solid method and has a transparent pricing structure). Also, frequent promotions often let you buy perpetual access to all courses for just a bit more than two years of Super Duolingo.

Currently I’m taking a traditional online course at the B1 level with a handsome, native-speaking human teacher, an e-learning platform, and useful interaction with my classmates, and I don’t have time for anything else. Once that course finishes, I’ll probably give Rosetta Stone a try.

In the meantime I’ll keep spending a few minutes a day on Duolingo, more out of habit and to review what I’ve learnt than to learn new material. Four years together aren’t easily forgotten!

Some people brag about completing a “course” in a year or less. Excluding the usual idiots on YouTube, they usually refer just to the A1 “level”, not the entire curriculum, which for German is structured across three levels: A1, A2, and B1. Studying just half an hour a day can comfortably get you through A1 in a year. ↩︎
Energy is currently active only on iOS; Android users and web‑app users have been exempt from this change for now. If this is a large‑scale A/B test, it doesn’t make much sense. ↩︎
There was also the option to restore the 5 Hearts by spending a certain number of “gems”, exactly like many freemium games. ↩︎

Surviving Don Rodrigo

Sun, 24 Aug 2025 06:00:00 +0000

– Source: Macworld.

The contrast between the two characters is striking. Tim Cook was born into a working-class family of the Deep South and rose to lead the world’s most important technology company through his own hard work and talent. He is openly gay and proud of it, as well as a defender of the rights of minorities.

Donald Trump is a spoiled rich kid who managed to fail in all his business ventures. He is a convicted rapist and a close friend of pedophiles. He likes to act like a boss, but he is actually just a cowardly chick.

Seeing Tim Cook forced to bow down before this petty Don Rodrigo is truly heartbreaking.¹

Still, Intel fared much worse, being forced to hand 10% of its shares to these new henchmen in suits and ties.

The only crumb of solace is that, at the end of the story, the plague will strike, and Don Rodrigo and his henchmen will get what they deserve.

Don Rodrigo is the main antagonist of Alessandro Manzoni’s novel I Promessi Sposi (The Betrothed). He is a petty lord who uses his social status and influence to prevent the marriage of the protagonists, Renzo and Lucia, out of pride and a desire to prove his power. Though a powerful figure in the novel’s setting of 17th-century Italy, Don Rodrigo is depicted as a morally weak and mediocre character, embodying the corruption and abuse of power prevalent at the time. For English readers, the figure that most closely mirrors Don Rodrigo is Judge Pyncheon in Nathaniel Hawthorne’s The House of the Seven Gables, a corrupt authority figure, feared in his community yet ultimately pathetic and doomed. ↩︎

Steve Wozniak, 75 years of happiness

Mon, 18 Aug 2025 06:00:00 +0000

I’ve always had great respect for Steve Wozniak, the tubby nerd who, in the eyes of those in the industry, has always been considered one step behind (if not more) his friend and Apple Computer co-founder, Steve Jobs.

Without Steve Jobs’ commercial genius, Apple would never have become the giant it is today. Instead, it would have remained just another company selling personal computers of various shapes and functions in the 1980s, alongside the likes of Tandy, Sinclair, Commodore, Osborne, Atari, Compaq and many others.

But without Steve Wozniak’s engineering genius, the Apple I and Apple II would never have existed, so I’d say it’s a draw.

– Source: TechCrunch_.

Steve Wozniak’s disinterest in money is legendary. Had it been up to him, he would have given away the Apple I project to anyone who asked. After leaving Apple in the 1980s, he sold or gave away most of his shares in the company, shares that would be worth a staggering amount today.

But, as he himself wrote on the day of his 75th birthday,

I gave all my Apple wealth away because wealth and power are not what I live for. I have a lot of fun and happiness. I funded a lot of important museums and arts groups in San Jose, the city of my birth, and they named a street after me for being good. I now speak publicly and have risen to the top. I have no idea how much I have but after speaking for 20 years it might be $10M plus a couple of homes. I never look for any type of tax dodge. I earn money from my labor and pay something like 55% combined tax on it. I am the happiest person ever. Life to me was never about accomplishment, but about Happiness, which is Smiles minus Frowns. I developed these philosophies when I was 18-20 years old and I never sold out.

He is right. Once you’re worth 10 million dollars (though it should actually be 100 million) your life doesn’t change whether you reach 20, 50, 100 or even 1,000 million. It’s better – much better – to have fun, enjoy life, and be happy.

If more people shared Woz’s philosophy, the world would be a much better place.

MDR Dasher vs. Flow 2: fashion or common sense?

Thu, 14 Aug 2025 06:00:00 +0000

It all started with Severance, the cult TV series that almost everyone liked.

To promote the final episode of the second season, Apple launched a webpage showcasing the Lumon Terminal Pro, the computer used by Lumon Industries employees – a replica of a vintage Data General terminal (more images available here and here). This sparked a race among fans to own a keyboard inspired by that terminal.

– Source: Apple.

– Source: Data General Dasher 6053 Terminal on Tech Tangents.

Someone built it themselves. Someone else started a company promising to produce the keyboard, and launched a Kickstarter campaign which will go live on 19 August. The first (lucky?) backers will be able to get the so-called MDR Dasher Keyboard at the discounted price of $599, which will rise to $699 for those who pre-order it after the Kickstarter launch. Those who buy it later through official channels will have to shell out $899, virtually the price of an iPhone 16!

I could be among those lucky ones, but I’ll gladly pass. I already use a keyboard that satisfies me 100%; actually I have two identical ones for my Macs at home and at the office. And I don’t even like the MDR Dasher: it’s too big, too tall, and too uncomfortable for my taste.

Above all, I don’t buy a product just because it’s trendy and looks like something from a TV series. And I definitely wouldn’t buy anything from an unknown company with a fake address, that was created just to capitalise on the current trend.

Instead, a keyboard that I would buy without hesitation is the Flow 2, a mechanical keyboard that has raised almost a million dollars on Kickstarter, one hundred times the initial request. This is not only because it is much more affordable – and very convenient overall for a mechanical keyboard – but because behind it is a reputable company that has been producing quality mechanical keyboards for years.

The Flow 2, in particular, is crafted from a single block of aluminium and features a refined, minimalist design, reminiscent of the Macs we all know and love. Even though it is a mechanical keyboard, you can choose a silent version, which is perfect for those who use the computer at night, or who simply don’t want to disturb family members or colleagues with the excruciating typewriter-like clicking that can be produced by a standard mechanical keyboard.

As the title suggests, on the one hand there’s fashion, hype and shameless marketing; on the other, common sense and a somewhat boring tranquillity. The choice is yours.

Last but not least, Happy Ferragosto to everyone! Unplug, switch off your devices, and enjoy a day of relaxation and good company.

Goodbye dc, welcome luka: a new RPN calculator for the Terminal

Sat, 09 Aug 2025 06:00:00 +0000

The Reverse Polish Notation (RPN) is a method for performing calculations without the need for parentheses. RPN was popularized in the ’70s and ’80s by Hewlett-Packard (HP), that used it in all its scientific and financial calculators.

When using calculators from rival Texas-Instruments, which all relied on parentheses, it was easy to lose track of how many parentheses had been opened or closed, often forcing users to re-enter the entire expression from scratch. Those who used an RPN calculator didn’t have these problems, although they had to overcome a small initial learning curve to get used to the new notation.

Today, physical calculators are rarely used, and almost everyone prefers to use an app on their phone or computer. However, there are still some die-hard nerds who refuse to give in to the graphical interface and insist on using the Terminal. Why? For example, because it’s much easier to enter numbers and complex operations with a keyboard than to press the glass keys of a virtual calculator.

– Image generated by Google Gemini.

A bit of history

Poland gave us Nicolaus Copernicus, Fryderyk Chopin, Joseph Conrad, Marie Curie, Arthur Rubinstein, and Stanislaw Lem. But it also gave us Jan Lukasiewicz, a mathematical logician (and philosopher) who, about a hundred years ago, invented a mathematical notation that did not use parentheses.

In this Polish notation, all operation symbols ( $ + $, $ - $, $ \times $, $ / $ ) precede the numbers they apply to. The same applies more generally to mathematical functions, such as $ \sqrt{} $, $ \sin $, $ \cos $, $ \exp $ (operators) and the numbers or variables (operands) they act on.

For example, $ 3 + 4 $ is written in Polish notation as $ + \ 3 \ 4 $, while $ (5 + 2) \times (5 - 2) $ becomes $ \times + 5 \ 2 - 5 \ 2 $.

For many years, this remained just an odd idea, because the benefit of not using parentheses didn’t seem to outweigh the unusual and more difficult-to-read notation.

Then, in the late ’50s, John McCarthy brought back Polish (or prefix) notation for LISP, one of the most influential programming languages of all time,¹ developed with the goal of being applied to the development of programs in the field of nascent artificial intelligence.

In fact, prefix notation not only greatly simplified the implementation of the LISP interpreter, but also made it possible to represent both code and data in the same form, an invaluable feature for a language designed to make computers intelligent. But better not to digress.

Reverse Polish Notation

But the real breakthrough came by inverting the order between operands and operators, that is, by writing the numbers first and then the operations to be performed on them, so $ 3 + 4 $ becomes $ 3 \ 4 \ + $ and $ (5 + 2) \times (5 - 2) $ becomes $ \ 5 \ 2 + 5 \ 2 - \times $.

This Reverse Polish Notation (RPN) was discovered and rediscovered at least three times in twenty years, but it only became popular in the early ’60s when Friedrich Bauer, the inventor of the concept of stack and one of the developers of the ALGOL computer language, and Edsger Dijkstra, famous for solving the “shortest path problem” and for a thousand other things, took up the concept again, because it reduced access to memory, which at the time was scarce and slow, and ensured that all operations were performed within a well-defined memory area (the stack), that was therefore easier to manipulate.

The advantages of RPN for performing mathematical calculations were so evident that HP used it in practically all its scientific and financial calculators, at least until the early ’90s. The development of larger memories and much bigger displays made it possible to easily view and modify the entire entered operation – not just the last number entered – thus reducing the necessity of using RPN.

A calculator in the Terminal

Those who wish to use a traditional calculator in the macOS or Linux Terminal have an almost mandatory choice: bc, the basic calculator, that has been a part of UNIX since 1975, a full 50 years. The current version, available on Linux and macOS, has been completely rewritten, but the original was just an interface for dc (desk calculator), one of the oldest utilities present in UNIX and even older than the C language.

And dc was… an RPN calculator. A choice that confirmed HP’s intuition: RPN notation was more efficient and easier to implement, and therefore also ideal for the limited-resource computers of the ’70s.²

Today, RPN is no longer a choice forced by hardware limitations, but rather a choice driven largely by convenience. Once you’ve spent half an hour learning to use it, you discover that it’s really much more convenient to perform calculations with this notation than with the traditional algebraic notation.

And then, maybe, there’s also a certain pleasure in going against the flow: in a world where everyone conforms to the dictates of (real or presumed) social media influencers, using an RPN calculator becomes a way to stand out, to feel different, almost a declaration of intellectual independence.

dc is still available on Linux and macOS and can be used in the Terminal, but it’s quite a hassle, its fifty years clearly show. The results of the operations are not visible unless you explicitly print them on the screen with p. The stack isn’t visible either, unless you explicitly request it with f. Negative numbers are indicated with an underscore _ and not with the usual - sign, so that $ - 4 $ must be written as $ _4 $. And so on.

But starting (almost) today, there’s dc2, or rather, luka.

The 21st-century RPN calculator

Since a few weeks we have a new RPN calculator for the macOS and Linux Terminal, initially called dc2, in homage to the venerable, now over-50-year-old calculator.

However, dc2 sounded too much like a rewrite of the original, while this is a completely new project, written from scratch in C. It therefore deserved its own name, luka, in honor of Jan Lukasiewicz, the inventor of the Polish notation (see the box above).

Compared to dc, luka is truly from another century, and it shows as soon as you start trying it out. It’s interactive, it shows the content of the stack at all times, it has a history of the operations, variables, a concise but complete inline help, a crystal-clear manual page (if only there were many more like this!)

And luka is also made in Italy. At a time when national identity is exalted for mostly trivial reasons, it’s nice to see something that really deserves to be valued.

The program currently has a small bug related to the display of the history, but the author crunches code much faster than I write words, so it’s very likely the bug will be fixed ASAP (vacations permitting).

Evolution of the code

The development of dc2/luka has been incredibly fast. Behind the project is Davide Mastromatteo, known among his pen pals as @mastro35 and author of the excellent blog The Python Corner.

In just a few days, Davide went from version 0.1.0, which was perfectly functional but had a still-raw user interface,

to version 0.2.0, with a much clearer view of the stack, the ability to use degrees and radians, and to change the number representation format, as well as a more compact help.

Version 0.3.0 introduced the history of operations and a further revised help,

while version 0.4.0, which coincided with the program’s name change, brought us variables and several new keyboard commands, as can be seen in the first two images of this post.

Using luka

Installing luka on a Mac or Linux is a breeze, at least for those who use homebrew (and those who don’t should start doing so immediately)

brew install mastro35/homebrew-mastro35/luka

Otherwise, just download the latest release of the source code, unzip it, and run

make clean && make

from the Terminal, obviously after navigating to the directory that contains the source code.³

Needless to say, anyone who has make and a C compiler installed on Windows can also compile luka on that operating system.

I almost forgot: soon there will be packages for Linux, in both deb and rpm formats, and who knows, maybe also aur. Perhaps even an installer for Windows.

There’s little to add about using the calculator itself. Those familiar with RPN will feel right at home and quickly use luka’ to its full potential. Those who don’t know RPN might be tempted to try it, if only to try firsthand how much more convenient it can be to perform calculations with an RPN calculator compared to a traditional algebraic one.

There are countless guides to RPN, but unfortunately, they are all oriented toward explaining its use with a physical calculator, such as the now legendary vintage HPs, or with graphical emulators for Android or iOS.⁴

Compared to these guides, there are some differences to consider. The main one is that, lacking physical keys, luka (but also dc) requires you to press ENTER each time to insert a number or function. Some function names are also different, as are the commands for managing the stack or for saving and retrieving variables. For example, luka uses store and load for variables, while physical or emulated calculators generally use keys named STO and RCL (but if the author reads this post, maybe he will change them 😂). However, apart from these tiny details, the underlying logic doesn’t change.

For my part, I tried in every way to make luka crash, and never succeeded. I tested it with factorials of absurdly large or small numbers, divided by zero, performed the infamous$ 0 / 0 $ and then asked to calculate the reciprocal of the result. But no matter what, luka always returned the correct result. In short, the quality is definitely there.

Conclusions

Trying luka costs nothing. It installs (and uninstalls) in a few seconds, works on macOS, Linux, and, for those who want, even on Windows. The results it produces are exact (and this is the most important thing). The developer is skilled and open to suggestions. In short, it’s an ideal tool for anyone who wants to perform calculations from the Terminal.

Sure, it’s a niche tool, aimed at a select group of sophisticated users who appreciate RPN notation and are not afraid of the Terminal. But that’s also what what gives it its unique charm.

And then, what about the beauty of seeing a program evolve before our very eyes, maybe even participating in its development with suggestions or criticisms?

And beyond that, there’s something special about watching a program evolve right before our eyes, especially when you can join the development with your own suggestions or feedback.

And one of the few languages, along with FORTRAN and COBOL, to still be alive and well. ↩︎
Not by chance, one of the most efficient programming languages ever is FORTH, which is based on a stack and uses RPN. ↩︎
What, you don’t even have make? Then hurry up and install homebrew! ↩︎
For iOS, I recommend without hesitation PCalc Lite or, even better, the full version Pcalc, which costsbout as much as a sandwich and a small bottle of water at a café. Alternatively, WP 34s, which manages to compact everything onto a single screen, or i41CX, perfect for those who once dreamed of having one. ↩︎

Do a Maggie

Mon, 28 Jul 2025 06:00:00 +0000

The last post literally drove me crazy. Not because of the length, although writing a text of over three thousand words and twenty thousand characters in two different languages is no small feat.

The real problem started when, at some point, the Markdown file of the Italian version of the post got corrupted. Whenever Hugo tried to convert it to HTML, the generated file showed the dreaded replacement character � instead of Italian accented letters. This is that black diamond with a white question mark inside that we have seen in tons of emails and web pages.

It took me hours to fix the issue.

When a Markdown file gets corrupted

My first guess was that the file contained some rogue character, such as like a space that wasn’t really a space, or one of those weird letters that caused quite a stir a few years ago. Trying to hunt them down was a pain, so I did the opposite: I wrote a regular expression to match everything that wasn’t normal, and gradually refined it as I went.

In the end, the regular expression turned into this.

[^a-zA-Z0-9àèéìòùÀÈÉÌÒÙ ,.;:`'"()\[\]\-^/_*#\n]

It was a very down-to-earth regex, but it worked, and that was what mattered. Unfortunately, it didn’t find anything strange.

To narrow down the part of the text that might contain the error, I started removing chunks – first a few lines, then entire sections – rebuilding the trimmed file with Hugo each time. Nothing. Those damn black diamonds just wouldn’t go away!

And that’s when I did the one thing that really made a difference: after trying over and over with no success, I gave up and went to have dinner.

Yes, because when you’re stuck on a problem — whether it’s a tricky math exercise, a program that refuses to run, or the opening of a post that’s been in your head for hours — the best thing to do is give up and do something else. I don’t know about you, but it always works great for me.

And sure enough, after dinner the idea hit me: I did a Maggie, and everything was back to normal.

– Image generated by Google Gemini.

Do a Maggie

Maggie is the nickname of Margaret Secara, who became known for a simple but very effective trick to recover a corrupted Word document: click the ¶ icon in Word’s Ribbon to show formatting characters (if the Word window is narrow, the icon could be hidden inside the paragraph section), then select all the text except the final Enter character (as shown in the image below), and paste it into a new blank document.

If this does not work, you can repeat the process by copying consecutive sections of the text into a new document, in order to isolate the corrupted portion as much as possible.

The first time I used this trick, I was working on a document of over a hundred pages, which had been passed around several colleagues and multiple versions of Word, and had become unmanageable: each new character took seconds to appear on the screen and Word kept crashing. With the trick described above, I fixed the problem in no time.¹

Maggie’s trick works because Word files have a dual structure. The first is what is shown on the computer screen, consisting of text, images, and tables, divided into chapters, sections, and paragraphs, with bold, italics, underlining, page breaks, lists, and indents. All of which is placed somewhat randomly by the user.

The second structure is that of the underlying XML file, which, after a few additions, edits, deletions, and rethinking, becomes a messy tangle of nested XML tags. These, however, remain completely invisible to the user and are never properly cleaned up and reorganized by the program.

Unless we do it manually, copying all the text into a new document, but avoiding like the plague the last Enter character which, for some arcane reason, contains the access key to the hidden nasties within the Word document.

Margaret Maggie Secara may have discovered this trick by pure accident, but it turned out to be so useful that her nickname became a real word, like Kleenex, Band-Aid, Post-it, Tupperware, or Google.

But they are text documents!

However, I write my posts in Markdown, not Word. Even so, starting with a fresh document and copying the contents of the corrupted one into it can be the fastest way to solve many problems.

Of course, this trick works with any type of plain text document, whether it is written in Markdown, LaTeX, HTML, XML, JSON, Org mode… or any other format you can think of, no matter how obscure.

In fact, since a text document hides nothing from the user, unlike Word, there is no need to avoid copying the last Enter character. You can safely select all the text, copy it and paste it into a new, empty file.

Before doing so, it is always a good idea to check that the text does not contain any spurious characters, using a regular expression similar to the one shown above.

And with that, the post is complete. The two sections below are intended for the handful of readers who are curious to know what really happened to me.

Only for the curious…

Why does the trick work?

Once the immediate problem was solved, curiosity got the better of me and I wondered why the method described works with text documents. As is often the case, working from the Terminal helps solve the most difficult problems.

In a regular editor such as BBEdit or TextMate, the corrupted file looks perfectly normal. But if you view it in the Terminal using the cat command, you will immediately notice that all the accented characters are replaced by ?, which is more or less what happens when converting it to HTML.

The file command gives the definitive answer. When I apply it to the corrupted file, file 2025-07-22-macos-tahoe-developer-beta-3.md, I get the following response

Non-ISO extended-ASCII text, with very long lines (1264)

while with any other Markdown file, the result is (as it should be)

Unicode text, UTF-8 text, with very long lines (1264)

In other words, the file had lost the correct UTF-8 encoding, becoming a non-standard plain text file.

Had I noticed this earlier, I could have used iconv to correct the file encoding. However, there is no doubt that the copy-and-paste method is much more practical.

What really happened?

It’s hard to tell, but there are some clues. Since the post was very long, I wrote it in several stages, partly on my Mac Mini and partly on my Air.

I usually copy my work files locally and synchronize them later. But this time I was constantly switching computers, so I preferred to work directly on the synchronized folder (using Syncthing, but I don’t think it was its fault; otherwise I would have found conflicting files, which I didn’t). Instead, there were occasional network glitches, and I guess that these ended up corrupting the file encoding.

What’s the moral of the story? Work locally and synchronize only when you’re done. Or work directly on the network only when the connection is stable.

But when you can’t do that, remember the advice of the good old Maggie.

It seems that it might be possible to recover a Word document without losing track of the changes made. However, the guide uses keyboard shortcuts typical of Word for Windows, so it is not immediately applicable to the macOS version. ↩︎

macOS Tahoe: Developer Beta 3

Tue, 22 Jul 2025 06:00:00 +0000

A few days ago, right on schedule, Apple released to developers the third update of the macOS 26 Developer Beta, better known as Tahoe.

Once the update is complete, it doesn’t take long to realize that Apple is (slowly) modifying something in the Liquid Glass graphical interface of the latest version of its operating system.¹

Perhaps this is also to address the many criticisms it has received over the last month from big names like Riccardo Mori – whatever you think, his first article on MacOS Tahoe and Liquid Glass is a must-read (but his first and second follow-ups are also worth reading) – as well as from John Gruber, Craig Hockenberry, Francisco Tolmasky, Louie Mantia, Marco Arment and many others, as can be read in one of Michael Tsai’s masterful collections.² As well as, in my own humble and far less masterful writings (here and here).

It’s a beta

Let’s clear up a misunderstanding: constructively criticizing the beta version of an operating system, such as macOS, is a good and right thing to do.

When Apple releases a beta, they’re not doing us a favor by letting us preview an unreleased product. Rather, we’re doing Apple a favor by analyzing and dissecting their software in ways that might never have occurred to their official developers and testers.

To argue, as many do, that “you have to be patient, it’s just a beta” or that “betas always have bugs,” is utter nonsense, because it is precisely at this stage, when the product is tested in the field, that flaws emerge which official developers, accustomed to working on it every day for months, no longer notice.³

After all, if Apple has extended access to its Developer Betas to a much wider audience in recent years, it means that what is done in this phase is indeed useful to them!

The Wallpaper

The first thing you notice when you access your Mac after the update is the new default wallpaper, which now shows the rocky shore of Lake Tahoe, surrounded by a long chain of snow-capped mountains (in Nevada?).

I don’t particularly like these natural wallpapers; there are too many details that distract and prevent a clear view of what’s on the Desktop. However, compared to the anonymous wallpaper we had before (and which is still among the available wallpapers), this one is much better, so it’s all right. And the subtle ripple effect of the waves, which unfortunately isn’t visible in the screenshot, is truly delightful!

However, changing the active default wallpaper on the fly seems to hint some issues in the development direction of Tahoe/Liquid Glass, as will become even more apparent in the next section.

This, to be fair, is a change introduced in the previous beta, which I didn’t get a chance to write about here, yet. Apple has added an option to restore the menu bar background (System Settings > Menu Bar > Show menu bar background), just like in Sequoia and previous versions of macOS.

In my opinion, this is an excellent decision because, after using macOS Tahoe for a few weeks, I realized that having a transparent menu bar available is useless. For at least two reasons.

The first is that with a transparent bar, menu items and icons tend to blend into the background image, becoming much less legible. This effect is particularly severe when the wallpaper is full of details and gradients, as in the example below.

The difference in clarity when the menu bar has a background is evident.

The second reason is that, even if the menu bar is transparent, it cannot (rightly) be occupied by application windows, so you don’t gain useful space for applications.

What is the real purpose of a transparent menu bar if it is less legible and doesn’t provide more useful space for applications? It is just to achieve a (questionable) more homogeneous visual effect without any functional advantage?

Most people use their computers to work. They don’t spend all day admiring the desktop. Why should they struggle to read the menu items or the battery level, the Wi-Fi strength, and all the other icons that are there for a specific purpose, just because some dime-a-dozen designer decided that the menu bar should blend in with the desktop?

It is striking, though, that after no less than two Developer Beta releases, this setting has still not been translated into Italian and, I imagine, other languages. It is a small detail, but that gives the impression of a half-baked, thrown-together thing, something that the team working on this part of Tahoe is still not quite clear on.

This reinforces doubts about how Tahoe’s development is progressing, as expressed very well by Craig Grannelli.

[this change] also makes me question Apple�s confidence in its design work. When Apple starts hedging its bets, it signals that it knows something is wrong, but lacks the conviction to course-correct. Or perhaps such settings are a means to temporarily shut people up, while default choices reveal the true intent and direction of travel.

System Settings

In my first article on Tahoe, I reported that the new Appearance item in System Settings behaved strangely: setting the Auto mode in the section related to Dark, Clear, and Tinted icon (and widget) styles apparently had no effect.

In the article, I supposed that this mode would allow the operating system to automatically adapt the display details of the chosen icon and widget style to the active Light or Dark mode. However, I also noted that the implementation seemed rather confusing.

Actually, it wasn’t a poorly implemented feature; it was a true bug, as reported in the Release Notes for this beta.

Finder
Resolved Issues

Fixed: Finder does not display Dark Mode app icons or tinted folder colors when the Folder Color setting in System Settings > Appearance is set to Automatic. (152193702)

Unfortunately, even though Apple claims to have fixed the problem, I don’t see any improvement. However, I clearly see that certain combinations of settings still result in such low icon contrast that it becomes difficult to tell them apart.

The Finder

As soon as I opened the Finder, I had the impression that Apple had reduced the shadow intensity of the separate groups of icons that now make up the Toolbar.

Unfortunately, this is not the case; the shadow intensity, as well as the icon transparency, is identical to before, producing the same color mess described in the previous article whenever the more colorful icons in the main Finder window end up beneath those in the Toolbar.

To avoid this, it would be enough for the Finder’s Toolbar to retain the white background present since Big Sur (that replaced the previous metallic one). This way, the icons shown in the main Finder window would be visible only in that window, without spilling over into the area reserved for the Toolbar.⁴

The more I use Tahoe’s new-Finder, the more I wonder what’s the point of this confusion, where the Toolbar – which isn’t there for beauty but to manage files and navigate the file system – has to blend and overlap with the files themselves, in an indistinct mix that isn’t even aesthetically pleasing?

Even Apple’s developers seem to have doubts about their choices, as switching from Icon to List view shows the usual clear separation between the main window and the Toolbar (apart from the three-dimensional effect added to the latter by Liquid Glass).

If we switch to Column view, we find a third, intermediate mode between the previous two. In this mode, the Toolbar has a white background, but where the icons of applications and files are blurred well before they reach the Toolbar, as happens in the normal Icon view.

This confusion in the display mode of the Toolbar is not only present in the Finder but also in applications like Notes where, depending on the chosen display mode, you can find yourself with a transparent Toolbar that blurs everything that ends up underneath it,

or with a normal Toolbar with a white background, as we are used to seeing since Big Sur.

Something similar also happens with Font Book, albeit with slightly different modes, while it doesn’t happen with Freeform or Preview, which always have a transparent Toolbar. Reminders is another special case, but I’ll leave you the pleasure to figure out why.

In short, there seems to be a great deal of confusion in Cupertino, and even the developers cannot decide what to do with the new Liquid Glass-style Toolbar.

Application Icons

I want to give the new application icons in the Finder their own section because, in this case, it’s no longer a simple matter of taste, but of the relationship between Apple and developers. After all, developers are fundamental to the success of a platform.

But first, let’s briefly recap the issue.

In macOS Tahoe, Apple has introduced a new icon format for applications, borrowed from iOS. The new icons have the shape of a squircle, a geometric shape intermediate between a circle and a square, and can be created with the new Icon Composer. This new format allows, among other things, to dynamically adapt the icons to the chosen style, or rather Appearance (see the System Settings section).

So far, so good.

The problem arises from the fact that there is no choice: the icons of all applications installed on the Mac can no longer have a customized shape, such as that of BBEdit which I am using to write this post, but must obligatorily adopt the squircle shape.

All application icons that have not yet adapted to the new style imposed by Liquid Glass are automatically enclosed in a squircle with an horrible dark gray background behind them, which seems to be placed there specifically to flag those bad products that have not yet conformed to Apple’s new guidelines.⁵

But redesigning icons is no piece of cake. For example, Bare Bones Software, which is certainly not an indie software house, has not complied yet. Its flagship product, BBEdit, was given a major update just a few days ago, but retained its traditional icon.

Independent developers are even less enthusiastic about having to redo all their application icons following the new format imposed by Apple.

One of them is Howard Oakley, who ironically calls macOS Tahoe the iconoclast, and equates the squircle with the gray background to a sin bin, as the area of the field where a player who has committed a foul is temporarily confined.⁶ Someone else goes even harder and calls the squircle a true prison.

Even those who decide to comply have problems because, as Howard Oakley tells us, updated icons for Tahoe may not work correctly in previous versions of macOS.

Half of the applications installed on the Mac that I updated to macOS Tahoe have grey icons. In the month and a half between the release of the first Developer Beta and today, I believe none of them have adopted the new icon format. This includes Google Chrome, which certainly has the resources to adapt quickly. Some Apple applications, such as GarageBand and Xcode, don’t even follow their own guidelines. The latter is particularly significant given that Xcode is the main tool for developing Mac applications.

My impression is that Tahoe’s graphical interface is not carved in stone -� oops, in glass – and that developers prefer to wait for the final version before conforming to Apple’s dictates.

After all, between Developer Beta 1 and Beta 2, Apple has already changed the Finder icon due to popular outcry, and has added the option to restore the menu bar background. So it’s clear that Apple is not insensitive to the criticisms expressed by those who are previewing Tahoe.⁷

I almost forgot: you can even restore the usual oddly-shaped icons in Tahoe. However, it’s a manual and rather tedious process, that must be repeated for each affected application and for each Mac. I’ll pass.

Performance

The third Developer Beta of macOS Tahoe seems much slower than the two previous versions. For example, Firefox takes forever to launch and restore previous tabs, but almost all applications seem more sluggish, especially at startup, than is reasonable to expect on Apple Silicon. Some ‘System Settings’ panels appear completely empty at first and take several seconds to display the available options.

As annoying as it is, this is normal behavior in a beta, which by its nature is filled with debug code and immature or poorly tested functions that may generate memory leaks, erroneous cache usage, and the like. I only mention it here because the first two Developer Betas appeared much more responsive than this one.

In any case, restarting the system solves the problem, at least temporarily, while we await the release of the final version.

Conclusions

In a few days, perhaps even tomorrow, Apple will make the Tahoe beta available to everyone, so that it can be tested by a much wider and more diverse audience.

As I said earlier, the fact that the Finder icon was changed mid-development demonstrates that Apple is listening to criticism about the new macOS interface. So there is hope that other issues will be resolved in the two months remaining until the official release of the new macOS version.

If someone thinks that critical posts like those cited above, and maybe even the little notes you’ve just read, are written solely for the purpose of getting easy clicks… well, never mind, the authors will come to terms with it.

If someone thinks that critical posts like the ones mentioned above, or maybe even the humble piece you’ve just read, are written purely to get easy clicks, well, never mind… the authors will come to terms with it.

Apple is doing the same with the corresponding version of iPadOS (which I’m testing on my iPad Pro) and iOS (which I’m leaving alone for now). ↩︎
Riccardo Mori describes himself as a translator and writer, but in reality he also has extensive expertise in the field of design and typography. John Gruber has been writing one of the most important blogs dedicated to the Apple universe for more years than I can remember and is the inventor of Markdown. Craig Hockenberry is a developer who has produced, among other things, Tot, which I adore, and is one of the souls of Iconfactory. Francisco Tolmasky was a member of the original iPhone team, where he helped develop Safari for iOS, and is the creator of Objective-J, a superset of JavaScript, and Cappuccino, an “open source framework that simplifies the creation of desktop-class applications running in a web browser”. Louie Mantia is an artist and graphic designer specializing in icon design. Marco Arment is an iOS and web application developer, as well as a “writer, podcast producer, geek, and coffee lover.” ↩︎
More or less the same thing happens when writing: if you have a text read by a third person, they will much more easily notice errors that the author, who now knows the text by heart, no longer pays attention to. ↩︎
As has always been the case, not just in macOS (or Mac OS X, or whatever you prefer to call it), from Sequoia all the way back to Cheetah, but also in the versions of Mac OS released throughout the ’80s and ’90s. ↩︎
To make a sporting comparison, Apple seems more or less like that soccer referee who pulls out a yellow card while warning the striker that “one more silly mistake and I’ll send you off.” ↩︎
I swear that when I wrote the soccer comparison in the previous note, I had not yet read this comment by Howard Oakley. ↩︎
I can’t help but think that if Steve Jobs had seen what some of his Finder icons have become, he would have kicked those responsible right out the window. ↩︎

macOS Tahoe: where is my Terminal?

Tue, 08 Jul 2025 06:00:00 +0000

– Image generated by Google Gemini.

Take macOS Tahoe, updated to version 26.0 Developer Beta 2, and open the Terminal. Actually, don’t just open one Terminal; open two, three, four different Terminals, each in its own tab. More or less like this:

Now tell me: which is the active Terminal?

In order to answer you need to look closely. Only then you will notice that the title bar of the active Terminal has a slightly darker background and that the title itself is in bold.

Do the same with Sequoia, or any other previous version of macOS, and the Terminal in use will be apparent at first glance.

Actually, there is also a way to tell which Terminal is active in Tahoe, but it is counterintuitive and requires the use of the mouse. If you hover the mouse over the active tab, nothing changes visually,

while, when you move the mouse over an inactive tab, its background gets darker.

To many, it may seem like a minor detail, but the Terminal is an essential tool for interacting with the operating system at a low level. Those who use it can’t afford to waste time figuring out which panel is the right one, nor can they risk running a dangerous command in the wrong Terminal.

To give a practical example: for managing this blog, I use three different Terminal panels, each of which is dedicated to a specific task. In one panel, I work via ssh on a test site, which I use to check that everything works properly before uploading the blog to the live server. Since this is only a test environment, I’m accustomed to wiping everything out with the command rm -r *. I can do that without worry because I can tell at a glance that I’m in the right Terminal, without even reading. However, with Tahoe, I’ll have to change my habits because running that same command in the wrong Terminal could have catastrophic consequences.

Among all the inconsistencies in macOS Tahoe, this is perhaps the most baffling. And potentially the most dangerous.

At this point, one can’t help but wonder: do Apple’s developers actually use the products they create?

macOS Tahoe: see you in September

Sat, 28 Jun 2025 06:00:00 +0000

It’s becoming a habit. Earlier this year, instead of waiting, like I usually do, for the next version of macOS to be ready (or nearly ready) before installing the current one, I installed Sequoia on all my Macs. A few days ago, I decided to take the plunge and install the very first developer beta of Tahoe on a Mac that I don’t use much, mainly to try out the new Liquid Glass interface on macOS.¹

Since this is my first time trying a macOS beta, I cannot say whether previous versions were more or less mature than Tahoe at this stage of development, which admittedly is still far from the official release.

Therefore, I will share my first impressions of the new interface here, focusing in particular on the Finder, which is one of the most frequently used applications, and on System Settings, which is essential when getting familiar with a new operating system. After the official release in September, there will be time for a more in-depth evaluation.

Update

The update from Sequoia 15.5 to Tahoe 26 Beta weighs just over 7 GB, which seems in line with previous updates, and perhaps even slightly below average.

The installation of the new operating system is fast. I dont’t know exactly how long it took, but I was surprised when I found out that it was already finished.

After the update, the first thing you see is this screen, which gives a preview of Liquid Glass, with the buttons raised above the rest of the window. Here, there is no visible transparency effect yet, but there will be time for that, too.

Desktop and widgets

Once you click Continue, the Tahoe Welcome Screen appears, which, poor boy! looks like toothpaste writing overlaid on my Mac’s default background. Sadly, the days of the magnificent Welcome Videos of the early macOS versions with the big cat names are long gone.

From here, you go straight to the Mac Desktop, which now displays a few widgets on the left-hand side of the screen (some of the widgets do not show any information just because the screenshots were taken late at night, with an inactive internet connection).

I’ve never really liked widgets. On Tiger and later versions, I used a few, but only because they were neatly tucked away on a separate screen, the now forgotten Dashboard. Having them on the Desktop, which I use all day, just annoys me. I already know that, as soon as I finish this post, I’ll remove them without hesitation.

But there’s time for that. For now, I’m just going to change the wallpaper to Tahoe’s default.²

I’m not thrilled with the new wallpaper: there are too many details and gradients for my taste, and the contrast with light icons, such as the disk icon, is too low. But no one is forcing me to use this exact wallpaper, so this is a non-issue.

Finder

A true problem, however, are the application icons with the dark gray background, which literally make me jump out of my seat when I first opened the Finder.³

The original icons had a transparent background, which can be noticed simply by changing the background of the Applications folder in Sequoia or earlier macOS versions. For reasons beyond understanding, in Tahoe this invisible background is replaced by a dark gray tone, that is an understatement to define as ugly.

Clearly, Apple applications do not have this issue. However, as shown in the previous image, some of the most popular ones are affected by it, with Google Chrome being one of the main examples.

However, when I scroll down towards the less popular apps, I find lots of ugly icons bordered in gray! In some cases, the icons have even been shrunk, presumably due to the new dynamic scaling rules of Liquid Glass, making the gray area around them even larger. Who on earth came up with something like this?

This is not the only questionable aspect of the new Finder. Here, the familiar Toolbar has been replaced by separate groups of translucent icons that seem to float above the main window.

The change feels somewhat rushed, especially since they forgot to raise also the folder name. That said, the new toolbar can be considered acceptable, even if inconsistent, when there is a light background behind the icons (as shown in some of the images above).

But when the translucent icons of the Toolbar overlap the most colorful icons of the main Finder window (as shown in the image below), the result is a chaotic, unpleasant mix of colors, that makes it hard to tell one Toolbar icon from another.

Maybe using a stronger blur effect or reducing the transparency might help to avoid the issue. However, wouldn’t it be better to just stick with the old white toolbar, with the new floating icons on top?

And yes, I understand that everything must speak the liquid concept now, but was it really necessary to turn the cursor in the Finder’s status bar (the one in the bottom right corner that lets you resize the icons) into such a huge yet barely visible capsule?

On the other hand, the new Trashcan isn’t bad at all; it looks more modern than the classic cylindrical one we have always had. I do wonder how it would stand upright, but it is clear that skeuomorphism has been dead for a while now.

Still on the topic of the Finder: could someone explain why the Settings window in the Finder still has the slightly rounded corners from Sequoia, and why its icons look thinner than those in the sidebar of the main window?

The new Apps

The new Apps application, on the other hand, isn’t bad at all: it groups installed apps in a logical way, more or less as iOS already does. It definitely looks better than Launchpad, which I tried to use but quickly gave up on,⁴ though I don’t like the fact that it takes two clicks to access the apps in a given group.

Mission Control hasn’t changed, and I’m totally fine with that. I use it a lot, and I wouldn’t like to break my habits. The same goes for Chess, which I never play because I always lose, but that has been a part of macOS since… forever (and was present in its forefather, NeXTSTEP, too).

The other default applications don’t seem to have changed much either, but I’ll save a more detailed analysis for later.

System Settings

Lastly, a look at System Settings. I won’t to comment on how confusing it has become. Up to Monterey, a quick glance was enough to find what you needed. But ever since macOS started mimicking iOS, you basically have to rely on the search function every time you need to find some setting.⁵

What I will comment on is the new feature that globally changes the color of macOS Tahoe icons and widgets. Here you can see the Default icon (and widget) style which, aside from the grayish border I mentioned earlier, is what we have always been used to seeing.

This image shows what happens when the Dark style is enabled. While all the Apple icons visible in the Dock do change, the application icons shown in the Finder do not —- probably because they need to be updated to support this new style. However, the Light theme doesn’t really do this new style justice,

whereas with the Dark theme, it’s a whole different story.

However, if I enable the Dark style and select the Auto mode, the entire interface reverts to looking exactly like the Default style. You can see it in the two images below: the first shows the Mac screen with the Dark style and Auto mode enabled, while the second shows the Default style.

I assume that the Auto mode is supposed to allow the operating system to automatically select the styling that best fits the current Light or Dark mode. While this makes sense, it might need a different implementation; as it stands, it just ends up being confusing.

The other two styles, Clear and Tinted, are nice enough, but personally I don’t like the idea of having all the icons in the same colour. I’m sure plenty of people will appreciate these new uniform styles, but I doubt I’ll ever use them myself.

Even with these styles, the Auto mode automatically adjusts the appearance to match the active theme. Here too, I think that both the placement and the labeling of the automatic mode needs some improvement.

Not bad at all, the option to change the accent color of the user interface.

I’m not really into these things, but a lot of people like them, and since they don’t overhaul the interface, why not?

The final gem is the huge switch that toggles Bluetooth (as well as Wi-Fi and VPN). True, even in Sequoia these switches were larger than the others, but don’t you think Apple has gone a bit too far this time?

Conclusions (for now)

This ends up my quick overview of macOS Tahoe and its Liquid Glass interface. If I gave the impression that I’m not thrilled about it, well, that’s exactly how I feel.

I really appreciate that Apple had the courage to change, aiming to develop a consistent interface across all its devices. Liquid Glass definitely has a lot of potential, but it’s still quite immature on macOS, perhaps even more so than on the iPad. It reminds me of the metallic transition of Leopard, which needed several subsequent macOS releases to refine.

In any case, Liquid Glass is the future, and we’ll have to live with it for quite a few years. So it’s best to start appreciating its positive aspects now, and be patient with the negatives.

In the meantime, Apple’s developers have fixed the flipped Finder icon, which caused quite a stir. Hopefully, before the official September release, they’ll do the same for the many other oddities and inconsistencies.

On the iPad, Liquid Glass is very interesting, though still quite immature. ↩︎
Unless they’re really ugly, like some Linux wallpapers, I always stick with the default backgrounds. I’m not a fan of extreme system customization, and using the default wallpaper helps me to instantly recognize which OS version I’m running. Besides, macOS default wallpapers are almost always really beautiful. ↩︎
Actually, these grayish icons were already showing up in the Dock. But due to the late hour or the low contrast, I hadn’t really paid attention to them. ↩︎
For example, because it used to lose the carefully set layout and didn’t allow syncing it across multiple Macs. ↩︎
Some might suggest that having a similar layout between macOS and iOS is a good thing. Indeed it is, but unfortunately iOS settings have always been one of the most confusing things I’ve ever seen. Therefore, it would have made more sense to adapt the macOS settings model to iOS, instead. ↩︎