Doing the GISTRE major on macOS (Apple Silicon)

February 13, 2025 · 7 min read

macOSApple SiliconGISTREEPITA

I originally wrote these notes for EPITA's internal GISTRE documentation. GISTRE is about low-level systems and platform engineering: systems, infrastructure, embedded. A lot of people thought it was impossible to follow the courses and projects on a Mac. I never hit a major blocker — here's how. The exact project lineup changes from one class year to the next, so some details below (like the projects mentioned) may have changed since.

Introduction

Is it possible to do the whole GISTRE major on a Mac? The answer is yes (99.999999% of the time). There are a few exceptions, and I'll share some tips here for getting by on your Mac.

Processor architecture

There are two types of Mac processors on the market today: Intel and Apple Silicon (ARM).

I did the major on a 2020 MacBook Pro with an Apple Silicon M1 chip, with no more trouble than on an Intel one. (I've since moved to a MacBook M5 Pro, but everything described here happened on that M1.) As a GISTRE student, I was able to do every project on this Mac except one: the HTS project. It required recompiling the OpenBSD kernel for x86_64, and emulation was too slow — I used an SSH server instead.

Aside from HTS, there were two cases:

The easy case: the apps/binaries/toolchains were available for macOS (at least for x86_64, or better yet, natively for Apple Silicon).
The second case: they were only available on Linux distributions. The VHDL project needs a Windows VM for Quartus, but that's a separate topic.

Techniques

Here are a few tips for getting through GISTRE on macOS.

Native

The first option is to use macOS natively with its built-in tools. Most software is compiled for macOS (Intel and, increasingly, Apple Silicon). If your program is already available for macOS, there's nothing to do — it just works.

Homebrew

Homebrew is a very handy package manager for installing software on macOS. More info on the official site.

Warning

Homebrew updates all dependencies whenever you install a new package, which can break existing installs — be careful.

Nix-darwin

An interesting alternative to Homebrew is Nix-darwin, which brings the power of Nix to managing your packages more reliably. More info on the official site.

Warning

Nix is more complex than Homebrew, but it breaks dependencies less often — plenty of ready-made flakes/shells exist for the different courses in the major.

It seems possible to run Homebrew and Nix side by side, but I haven't tried it.

x86_64 emulation

If you have an Apple Silicon Mac, x86_64 software won't run natively. Fortunately, there are several ways to run it anyway.

Rosetta 2

Rosetta 2 is a compatibility layer that lets you run x86_64 applications on ARM processors. It's very performant, but it can't emulate everything — some software may not work. I use it daily, with very little performance loss on my x86_64 applications.

Installation:

softwareupdate --install-rosetta --agree-to-license

Restart your Mac after installing.

Most x86_64 applications launch automatically under Rosetta 2. If not, you can force an app to launch under Rosetta 2 by right-clicking it in Finder → Get Info → Open using Rosetta. If that option isn't there, the app is already native ARM.

Tip

Make a copy of your terminal app and enable Rosetta 2 for the copy: you'll end up with an x86_64 terminal and an ARM terminal. Run arch to check which is which.

QEMU

QEMU is a processor emulator — very performant — that lets you emulate an x86_64 processor on ARM.

In practice

Performant, but more complex to set up than Rosetta 2. Mostly useful for running virtual machines.

Containers

Docker Desktop (native)

Docker is a must-have for running containerized applications without touching the rest of your system.

When I can't get a program running natively, I run it in a Docker container. I won't go into the basics of using Docker here, but it's worth learning. Here's a useful example command:

# --rm to remove the container once it stops
# -it for an interactive terminal (like a regular shell)
# -v to mount a volume (here, the current directory), to share files between the container and the host
# -p to expose a port (here, port 8000) from the container to the host (host:container)
docker run -it --rm -v $PWD:/app -p 8000:8000 ubuntu:latest

Tip

To avoid re-downloading dependencies on every build, use a custom image with a Dockerfile.

For embedded work, this isn't ideal, since the container doesn't have access to the host machine's peripherals. For everything else, it's nearly perfect.

Docker (Rosetta 2 emulation)

You can run x86_64 containers on an ARM processor with Docker, using Rosetta 2.

Setup:

Go to Docker Desktop → General → Virtual Machine Options.
Check Use Rosetta for x86_64/amd64 emulation on Apple Silicon.
Apply and restart Docker Desktop.

(Docker Desktop's menus get reorganized from one version to the next — look for an equivalent setting if this path no longer matches exactly.)

Running an x86_64 container:

docker run --platform linux/amd64 -it --rm ubuntu:latest
docker build --platform linux/amd64 -t my_image .

You'll get a warning every time you run an x86_64 container (this used to be an error) — that's expected.

Virtual machines

If native execution or containers don't work, a virtual machine can be the answer.

ARM VM

Some of the options:

UTM (free outside the App Store)
VirtualBox (free)
Parallels Desktop (paid, with a student rate)
VMware Fusion (paid)

I personally used Parallels (VirtualBox and VMware didn't support ARM at the time): it's expensive, but it integrates well on Mac.

Tip

Windows 11 ARM (compatible with Parallels) offers an alternative to Rosetta 2 for Windows x86_64 software — decent performance, nothing more. Concrete example: Quartus, for the VHDL course.

Emulated VM

Options I tested:

UTM (GUI for QEMU)
QEMU (command line)
Parallels Desktop (built-in Rosetta 2)

UTM wraps QEMU with a UI, so you don't have to fight the command line. On my two attempts, performance wasn't great (one of the two VMs never finished booting), but a classmate managed to run an x86_64 Linux kernel smoothly with UTM. The EpiMac association also wrote an article on using UTM to run x86_64 Linux on an Apple Silicon Mac: link. Parallels is decent for x86_64 VM emulation.

Save this for Linux VMs: Windows 11 ARM already runs Windows x86_64 software natively (through its own equivalent of Rosetta).

Going further

Asahi Linux

Asahi Linux is an open-source project aiming to port Linux to Apple Silicon Macs. Well worth following — the project moves fast, so check its current status when you're reading this. The EpiMac association wrote an article on the topic: link.

Getting resourceful

If you get to this point, you're genuinely stuck (or on the OpenBSD project). As a last resort, there's always an SSH server — the 0.000001% of the time when nothing else works and you need x86_64 Linux. Also remember most projects are done in groups, so you can always ask your teammates for help.

Conclusion

Doing the GISTRE major on macOS is entirely possible, whether your Mac is Intel or Apple Silicon. Between native solutions, emulation, containers, and VMs, there's no shortage of ways to get your tools running.

If you have any questions, feel free to reach out.