Here’s the JavaScript function to convert a three-dimensional point into a two-dimensional one:

function to_isometric(point) {
  const angle = Math.PI / 6; // 30°
  const cos = Math.cos(angle); // ≈ 0.866
  const sin = Math.sin(angle); // = 0.5

  return {
    x: (point.x - point.y) * cos,
    y: (point.x + point.y) * sin - point.z
  };
}

If you can’t convert this into the programming language you’re using, you don’t deserve to have an isometric design in your game.

More detailed explanation

Isometric graphics were and still are common in games. This style offers a kind of blend between 2D and 3D that creates a unique look.

The game SimCity is an example of one that uses the isometric art style.

Isometric drawing works through three lines separated by 60º from each other, where each represents a dimension. These lines allow you to convert a three-dimensional point into a two-dimensional one using orthographic projection:

The math behind it

In isometric drawing, as mentioned, we have three lines separated by 60º from each other. However, since the Z axis is completely vertical, let’s focus, for now, only on X and Y:

As you can see, the X and Y axes are at an angle of 30º relative to the real X axis (in the previous case they were at angles of 60º from each other). So the first thing to do is to find the points on each line according to the distance from the origin — which can be done with sine and cosine. For this, let’s suppose a three-dimensional point T = (3, 5, 0) (the Z dimension won’t be considered for now), and we want to find a two-dimensional point A (on the X line) and B (on the Y line):

Calculating A and B:

Plotting the points on the graph:

Now, to find the real point R — the one that will be drawn on the screen — we need to add the two vectors:

Plotting it on the graph:

To add the Z axis, just add this value to the real Y value plotted — since the Z axis is completely vertical —, so if the Z value of point T were 3, the position vector to be drawn would be $\begin{pmatrix} -1.74 \ 7 \end{pmatrix}$.

Generic function

A generic function would look like this:

Why is Z subtracted in the JavaScript function instead of added?

If you’re very observant, you may have noticed this. The reason is that in most graphics libraries (SDL, HTML Canvas, Raylib, p5.js, etc.), the smaller the Y value, the higher the point appears — which is the opposite of most Cartesian planes, like GeoGebra’s, which I used to demonstrate how it works. However, if you’re using a game engine like Unity or Godot, you should change it to add instead of subtract.

Implementing in p5.js

By opening editor.p5js.org, there’s an online editor where you can program in JavaScript using the p5.js graphics library — it’s not one of the best for creating games, but it’s very easy and widely used for learning programming.

Initially, a code like this will appear:

function setup() {
  createCanvas(400, 400);
}

function draw() {
  background(220);
}

The setup function runs only once, at the start of the game, while draw runs every loop. Running it, we only see this:

What we want to do is create a grid that moves like waves, and for that, we’ll use the function from the TL;DR. Then, we’ll draw equally spaced points using that function:

[...]
function draw() {
  background(220);
  
  // Put the camera in the center
  translate(width/2, height/2)
  
  const grid_size=5
  const grid_distance=30
  for (let y=-grid_size; y<grid_size; y++) {
    for (let x=-grid_size; x<grid_size; x++) {
      // Transform 3D point into 2D
      let drawn_point = to_isometric(
        {x: x*grid_distance, y: y*grid_distance, z: 0}
      )
      
      // Draw the point
      stroke(255, 0, 0)
      strokeWeight(3)
      point(drawn_point.x, drawn_point.y)
    }
  }
}

Thus, the result is this:

Animating the points

For this, we’ll use the sine function, which, on a graph, looks like this:

Passing the time since the start of the program into the function, which can be done with p5.js’s millis() function — it returns how many milliseconds since the start of execution — we can animate them:

let drawn_point = to_isometric(
  {x: x*grid_distance, y: y*grid_distance, z: Math.sin(millis()/1000)*20}
)

Result:

However, as we can see, all the points move equally. To change this, let’s add an offset value for each point, defined by their Y position:

let drawn_point = to_isometric(
  {x: x*grid_distance, y: y*grid_distance, z: Math.sin(millis()/1000+y)*20}
)

Result:

Adding sprites

For this, I’ll use these sprites from opengameart.org. Then, I cropped and reduced the resolution in GIMP so it’s just a cube:

Download this image and place it in the editor. To do this, create an account and then click the arrow on the left side of the editor, then click the “plus” symbol and “Upload file,” and select the cube file.

To draw the cube, define a global variable called cube:

let cube

Then, inside the setup() function, assign the variable as the cube texture:

cube = loadImage('cube.png')

And instead of drawing the point, draw the texture, remembering to keep its size as grid_distance times two:

/*stroke(255, 0, 0)
strokeWeight(3)
point(drawn_point.x, drawn_point.y)*/
image(cube, drawn_point.x, drawn_point.y, grid_distance*2, grid_distance*2)

Result:

Linux Mint is known as one of the most popular Linux distributions for beginners, being based on Ubuntu LTS — providing good stability — and featuring a graphical interface with a desktop paradigm similar to Windows.

Main changes

Sticky Notes

Linux Mint 22.2 comes with improvements to sticky notes, such as now having rounded corners and support for Wayland, which is the most modern desktop technology — standard in most distros such as Fedora, Arch, and Ubuntu. In the latest Mint updates, support for Wayland in its interface, Cinnamon, has been improved.

New look of sticky notes

Login Screen

The login screen has been updated with a new look featuring a blur effect and user avatars:

Fingerprint Authentication

Linux Mint 22.2 includes a new application called Fingwit, which allows you to register fingerprints and use them to unlock the screen, in Sudo, and in administration applications.

LibAdwaita Compatibility

This is, in my opinion, one of the best changes.

LibAdwaita is a library created by GNOME to follow its design guidelines, maintaining a consistent look across all programs — similar to how Apple does with Cocoa. However, it comes with the drawback of having a completely out-of-place look on distros that don’t use GNOME, such as Linux Mint.

Previously, Linux Mint used older versions of GNOME applications that did not use the library to maintain consistency. However, now they have started modifying it so that the global theme is applied:

As we can see, applications like Gnome Calendar — which use the library — now have their theme more consistent with the system’s defined theme, unlike previous versions where, regardless of the theme, they would always have the same look.

The fork is available on GitHub under the name LibAdapta.

How to update

To update Linux Mint to the latest version, it is recommended to first make a backup of your files, which can be done using the distro’s own tool, Timeshift.

After that, go to the update manager, click “Edit” and then “Upgrade to Linux Mint 22.2 Zara”:

Then, restart your computer and you should have the latest version installed.

However, most of the popular AI models are closed: they run on closed software on a closed server — they don’t run natively on your computer. Instead, your message is sent to a server, processed there, and then the result is returned.

Nevertheless, it is quite easy to run AI models natively on your computer using Ollama, a tool written in Go for handling and running LLMs. Keep in mind, though, that without a powerful computer you won’t be able to run the best models, but you can still experiment with simpler ones.

The first step is to install Ollama. You can use the official installer, build from source, or install it via your Linux distro’s package manager. On Fedora, for example:

sudo dnf install ollama  

Once installed, start the Ollama server by typing:

ollama serve  

And to run a model, type:

ollama run <model name>  

There are several options, such as DeepSeek and GPT-OSS. However, on a weaker machine without a dedicated GPU, larger models won’t run. That’s why you should look for models with fewer parameters — for example, in the Qwen3 models:

As we can see, there are many. The ‘b’ stands for billions of parameters, so qwen3:8b has 8 billion parameters, and qwen3:0.6b has 600 million parameters. Running a large model requires not only a good GPU but also a lot of VRAM. Smaller models, up to 4 billion, can be run on the CPU.

In my tests, the best models are Qwen3, Gemma3, and LLaMA 3.2. They are small but can still be useful. Other models, like Deepseek R1 in their basic versions, make many mistakes and can’t even speak Portuguese properly.

For example, to run the 1-billion-parameter Gemma3, you would do:

$ ollama run gemma3:1b  
>> Hello, how are you?  
Hello, I’m fine, thank you for asking! How are you doing? 😊

And you, how are you? How can I help?  

To list models, use ollama list, and to remove one, use ollama rm <model>.

How to Run on Your Phone

To run it on your phone, install Termux — an open-source Linux terminal for Android —, install Ollama with pkg install ollama, and follow the same steps as mentioned above.

As a result, Firefox’s marketing shifted to focus on one keyword: privacy. That word is everywhere in Firefox. After all, Firefox is, in fact, more private than something like Google Chrome, which tracks everything you access.

But that has changed—with the browser’s new terms of service, it now includes this clause:

You give Mozilla the rights necessary to operate Firefox. This includes processing your data as we describe in the Firefox Privacy Notice. It also includes a nonexclusive, royalty-free, worldwide license for the purpose of doing as you request with the content you input in Firefox. This does not give Mozilla any ownership in that content.

Essentially, Firefox has rights over your data. Reading the Firefox Privacy Notice, we can see how that data is used:

• To provide the Firefox browser
• To tailor Firefox to your needs
• To provide and improve search functionality
• To provide relevant content and advertising on Firefox’s New Tab page
• To provide Mozilla accounts
• To provide AI chatbots
• To provide the Review Checker, including sponsored content
• To provide and enable add-ons (addons.mozilla.org)
• To maintain and improve features, performance, and stability
• To improve security
• To understand Firefox usage
• To market our services
• To pseudonymize, de-identify, aggregate, or anonymize data
• To communicate with you
• To comply with applicable laws, identify and prevent harmful, unauthorized, or illegal activity

Which is rather strange for a supposedly privacy-respecting browser. So, I’ll show a few alternatives I consider viable and, at the end, reflect on which one Zorin OS should have used, since Zorin OS switched its default browser to Brave.

Alternatives to Firefox

Brave

I’ll put this one last. Even though it has good default privacy settings, it has two major drawbacks:

• It’s Chromium-based
• It’s developed by a company

Regarding being Chromium-based, this is more of an ethical issue than a privacy or security one. I’m against Chromium-based browsers because they only contribute to Google’s monopoly over the internet. This is already evident with Manifest v2 being removed from Chromium, breaking critical privacy extensions like uBlock Origin. That’s why I support non-Blink browsers like Ladybird, which, although still slow, can already render pages well—YouTube videos included.

As for being developed by a company, I have nothing against companies contributing to open source projects, but the problem is when they start negatively modifying the project for users, which Brave has done by integrating AI and cryptocurrencies into the browser.

That said, it still has pros:

• Strong default privacy settings
• It’s open-source — absolutely essential

Zen

Zen is an open-source browser based on Firefox, which is already a plus. It is heavily inspired by the minimalist Chromium-based browser Arc. It has many features, somewhat reminiscent of Opera (in my opinion), with the advantage of being free software.

The interface might be a bit confusing for those used to traditional browsers, but it allows excellent tab organization and also has a compact mode where the page takes up the entire window.

Moreover, it’s not owned by any company, another positive point. However, it’s still in beta, though perfectly usable for daily use.

That said, it lacks good default privacy settings, so you’ll probably have to tweak things yourself if that’s a concern.

LibreWolf

This is by far one of the best Firefox alternatives when it comes to privacy. It looks a lot like Mozilla’s browser but comes perfectly configured for privacy, even including uBlock Origin by default.

Besides being open-source and not owned by any company, they don’t accept donations(!). From their FAQ, it says:

Why don’t we accept donations?

We don’t want to deal with the administration required to manage donations properly. If we don’t need funding, we won’t risk becoming dependent on it. And also: no donations means no expectations. That allows people working on LibreWolf the freedom to move on to other projects when they wish.

Despite all these advantages, LibreWolf’s default settings — though ideal for privacy and security — may pose challenges for average users:

• Uses DuckDuckGo by default — some may prefer Google
• Comes with uBlock Origin pre-installed — some sites might ask you to disable it
• Uses Firefox’s strict mode by default — some sites, including Twitter, may not work
• Deletes all cookies upon browser close
• Doesn’t ask to save passwords by default
• Disables DRM (Digital Rights Management) — for example, you can’t watch Netflix

Still, all of this can be easily changed in the browser settings.

Which of These Should Zorin OS Have Picked?

Answer: either let the user choose, or just leave Firefox.

The truth is that, unlike Windows, most Linux distros give you choice — meaning: a user who doesn’t care much about privacy can easily install Chrome and remove Firefox, while a more privacy-conscious user might install something like LibreWolf and remove Firefox.

However, something that few Linux distros do is offer that choice during installation. So far, the only distro I’ve seen doing this is Raspberry Pi OS, which gives you the option to install either Chromium or Firefox. That’s why it would be interesting if Zorin OS provided these browser options for users to choose:

• Chromium
• Firefox
• Brave
• LibreWolf
• No browser

Because, honestly, switching from Firefox to Brave won’t make much difference for most users, who will end up installing another browser anyway — just like nobody really uses Microsoft Edge.