• download the python source code
• compile it
• integrate it into pyenv
• and then use it

on an Apple Silicone Mac.

# prepare dependencies
brew install openssl readline zlib xz

# checkout python
git clone https://github.com/python/cpython.git
mkdir $HOME/.pythons
cd cpython
git checkout v3.13.3

# build
./configure \
  --prefix=$HOME/.pythons/python-3.13.3-nogil \
  --disable-gil \
  --enable-optimizations \
  CPPFLAGS="-I$(brew --prefix)/opt/openssl/include" \
  LDFLAGS="-L$(brew --prefix)/opt/openssl/lib"
make -j$(sysctl -n hw.ncpu)
make install

# integrate into pyenv
mkdir -p ~/.pyenv/versions/3.13.3-nogil
ln -s $HOME/.pythons/python-3.13.3-nogil ~/.pyenv/versions/3.13.3-nogil
# verify installation
pyenv versions | grep 3.13.3

pyenv shell 3.13.3-nogil
python3 --version
```

I’ve also tested it with a script that allows to run with different numbers of parallel threads:

import sys
import sysconfig
import math
import time
import threading
import argparse


def compute_factorial(n: int) -> None:
    """Compute the factorial of a single number (no return, just for load)."""
    math.factorial(n)


def multi_threaded_compute(numbers: list[int], thread_count: int) -> None:
    """Distribute factorial computations across multiple threads."""
    threads = []
    # Split the workload into chunks for each thread
    chunks = [numbers[i::thread_count] for i in range(thread_count)]

    def worker(sublist: list[int]) -> None:
        for num in sublist:
            compute_factorial(num)

    # Start threads
    for sublist in chunks:
        thread = threading.Thread(target=worker, args=(sublist,))
        threads.append(thread)
        thread.start()

    # Wait for all threads to finish
    for thread in threads:
        thread.join()

    print("All factorials computed.")


def check_gil_status() -> None:
    """Print whether the GIL is active or disabled."""
    gil_status = sysconfig.get_config_var("Py_GIL_DISABLED")
    if gil_status is None:
        print("GIL status: Unknown or not supported on this build")
    elif gil_status == 0:
        print("GIL is active")
    elif gil_status == 1:
        print("GIL is disabled")


def parse_args() -> int:
    """Parse and return the number of threads from command-line args."""
    parser = argparse.ArgumentParser(description="Multithreaded factorial computation")
    parser.add_argument(
        "threads",
        type=int,
        help="Number of threads to use (must be a positive integer)",
    )
    args = parser.parse_args()

    if args.threads <= 0:
        parser.error("Thread count must be a positive integer")

    return args.threads


def main():
    print(f"Python version: {sys.version}")
    check_gil_status()

    thread_count = parse_args()
    numbers = [100_000, 200_000, 300_000, 400_000, 500_000]

    start_time = time.time()
    multi_threaded_compute(numbers, thread_count)
    elapsed_time = time.time() - start_time

    print(f"Time taken: {elapsed_time:.2f} seconds")


if __name__ == "__main__":
    main()

Run on locally built python with GIL disabled:

% time python3 test.py $(sysctl -n hw.ncpu)

Python version: 3.13.3 experimental free-threading build (tags/v3.13.3:6280bb54784, Apr 11 2025, 13:01:07) [Clang 17.0.0 (clang-1700.0.13.3)]
GIL is disabled
All factorials computed.
Time taken: 2.47 seconds
python3 test.py $(sysctl -n hw.ncpu)  6.09s user 0.04s system 235% cpu 2.608 total

Run with same python version from brew with GIL enabled:

% time python3 test.py $(sysctl -n hw.ncpu)

Python version: 3.13.3 (main, Apr  8 2025, 13:54:08) [Clang 16.0.0 (clang-1600.0.26.6)]
GIL is active
All factorials computed.
Time taken: 6.26 seconds
python3 test.py $(sysctl -n hw.ncpu)  6.26s user 0.04s system 99% cpu 6.360 total

Disabling GIL brings runtime down to 2.47 seconds instead of 6.26. Disabling the GIL made the program about 60% faster

Check the cpu usage! It went up to 235% instead of 99%.

Here a small comparison to run the same in Kotlin with focus on multithreading:

import java.math.BigInteger
import kotlin.system.exitProcess
import kotlin.system.measureTimeMillis
import java.util.concurrent.Executors

fun computeFactorial(n: Int): BigInteger {
    var result = BigInteger.ONE
    for (i in 2..n) {
        result = result.multiply(BigInteger.valueOf(i.toLong()))
    }
    return result
}

fun multiThreadedCompute(numbers: List<Int>, threadCount: Int) {
    val executor = Executors.newFixedThreadPool(threadCount)

    val tasks = numbers.map { n ->
        Runnable { computeFactorial(n) }
    }

    tasks.forEach { executor.submit(it) }

    executor.shutdown()
    while (!executor.isTerminated) {
        Thread.sleep(50)
    }

    println("All factorials computed.")
}

fun main(args: Array<String>) {
    if (args.isEmpty()) {
        println("Usage: kotlin FactorialBenchmark.kt <thread_count>")
        exitProcess(1)
    }

    val threadCount = args[0].toIntOrNull()
    if (threadCount == null || threadCount <= 0) {
        println("Please provide a valid positive integer for thread count.")
        exitProcess(1)
    }

    println("Kotlin version: ${KotlinVersion.CURRENT}")
    println("Running with $threadCount threads")

    val numbers = listOf(100_000, 200_000, 300_000, 400_000, 500_000)

    val elapsed = measureTimeMillis {
        multiThreadedCompute(numbers, threadCount)
    }

    println("Time taken: ${"%.2f".format(elapsed / 1000.0)} seconds")
}

Result for the kotlin program running within JVM:

% time java -jar benchmark.jar $(sysctl -n hw.ncpu)
Kotlin version: 2.1.20
Running with 10 threads
All factorials computed.
Time taken: 92,55 seconds
java -jar benchmark.jar $(sysctl -n hw.ncpu)  199.58s user 1.49s system 217% cpu 1:32.65 total

So python is killing Kotlin in this use case. With or without GIL.

For completeness I also tried it with Java 21. It was nearly the same timing. So in this case it didn’t matter if the code was Kotlin or Java.

Interestingly even the go variant didn’t outperform python here:

% time go run main.go $(sysctl -n hw.ncpu)
Go version: go1.24.2
GIL is not applicable in Go (true concurrency with goroutines and OS threads)
All factorials computed.
Time taken: 16.26 seconds
go run main.go $(sysctl -n hw.ncpu)  32.77s user 3.37s system 217% cpu 16.626 total

package main

import (
	"fmt"
	"math/big"
	"os"
	"runtime"
	"strconv"
	"time"
)

func computeFactorial(n int) *big.Int {
	result := big.NewInt(1)
	tmp := big.NewInt(1)
	for i := 2; i <= n; i++ {
		tmp.SetInt64(int64(i))
		result.Mul(result, tmp)
	}
	return result
}

func worker(jobs <-chan int, done chan<- bool) {
	for num := range jobs {
		computeFactorial(num)
	}
	done <- true
}

func multiThreadedCompute(numbers []int, threadCount int) {
	jobs := make(chan int, len(numbers))
	done := make(chan bool)

	// Start fixed number of workers
	for i := 0; i < threadCount; i++ {
		go worker(jobs, done)
	}

	// Send jobs
	for _, num := range numbers {
		jobs <- num
	}
	close(jobs)

	// Wait for all workers to finish
	for i := 0; i < threadCount; i++ {
		<-done
	}

	fmt.Println("All factorials computed.")
}

func checkGILStatus() {
	fmt.Println("GIL is not applicable in Go (true concurrency with goroutines and OS threads)")
}

func main() {
	fmt.Println("Go version:", runtime.Version())
	checkGILStatus()

	if len(os.Args) != 2 {
		fmt.Println("Usage: go run main.go <thread_count>")
		os.Exit(1)
	}

	threadCount, err := strconv.Atoi(os.Args[1])
	if err != nil || threadCount <= 0 {
		fmt.Println("Invalid thread count: must be a positive integer")
		os.Exit(1)
	}

	numbers := []int{100_000, 200_000, 300_000, 400_000, 500_000}

	start := time.Now()
	multiThreadedCompute(numbers, threadCount)
	elapsed := time.Since(start)

	fmt.Printf("Time taken: %.2f seconds\n", elapsed.Seconds())
}

Step 1: Enter DFU Mode on Your GMMK Pro

To interact with the keyboard’s firmware, we need to put it into DFU (Device Firmware Upgrade) mode. To get out of this mode, simply power cycle the board. But make sure to NEVER power cycle a MCU while it is flashing. Otherwise you most likely will end up with a bricked device.

How to Enter DFU Mode:

1. Unplug your keyboard.
2. Hold down the Spacebar + B keys.
3. Plug the keyboard back in while continuing to hold the keys.
4. Your computer should recognize the keyboard as a STM32 BOOTLOADER device.

To confirm the device is in DFU mode, run:

lsusb | grep STM

Expected output:

Bus 002 Device 005: ID 0483:df11 STMicroelectronics STM32 BOOTLOADER

Step 2: Install dfu-util

We will use dfu-util to read and analyze the firmware stored on your GMMK Pro.

Mac (Homebrew):

brew install dfu-util

Linux (Debian/Ubuntu):

sudo apt update && sudo apt install dfu-util -y

Windows:

• Download dfu-util from the official dfu-util page.
• Extract the binaries and use dfu-util.exe from the command line.

After installation, verify it is installed by running:

dfu-util --version

Step 3: Read the Firmware from Memory

Now that dfu-util is installed, let’s extract the firmware to check its size.

Identify the DFU Device

sudo dfu-util -l

Example output:

Found DFU: [0483:df11] ver=2200, devnum=1, cfg=1, intf=0, path="0-1", alt=0, name="@Internal Flash /0x08000000/128*0002Kg", serial="205E36552033"

Dump the Firmware

Extract the firmware to a file for analysis:

sudo dfu-util -d 0483:df11 -a 0 -s 0x08000000:524288 -U gmmk_pro_firmware.bin

• -d 0483:df11: Specifies the device ID.
• -a 0: Selects the internal flash memory.
• -s 0x08000000:524288: Reads up to 512 KB from the microcontroller’s flash memory.
• -U gmmk_pro_firmware.bin: Saves the extracted firmware to a file.

Now, check the firmware size:

ls -lh gmmk_pro_firmware.bin

Expected output:

-rw-r--r--  1 user  staff   256K Jan 1 00:00 gmmk_pro_firmware.bin

Step 4: Determine Revision Based on Firmware Size

The firmware size tells us which revision your keyboard is:

• 256 KB (Rev1) → Uses the STM32F303 microcontroller.
• 512 KB (Rev2) → Uses the STM32F411 microcontroller.

Microcontroller Differences

Since Rev1 uses a smaller flash partition (256 KB), its firmware will never exceed that size. Rev2, on the other hand, requires larger firmware (closer to 512 KB).

Conclusion: Identifying Your GMMK Pro Revision

By following this guide, you can determine whether your GMMK Pro is Rev1 or Rev2 by:

1. Entering DFU mode.
2. Installing and using dfu-util.
3. Extracting the firmware and checking its size.

If your firmware size is 256 KB, you have Rev1. If it’s closer to 512 KB (over 256 KB), you have Rev2.

This method is non-intrusive and does not modify your keyboard’s firmware, ensuring a safe way to determine your revision.

#!/bin/sh -eu
NUMSECTORS=$(($1*1024*1024*1024/512))
echo "creating ramdisk with $1 GB ($NUMSECTORS sectors)"
MYDEV=$(hdiutil attach -nomount ram://$NUMSECTORS)
echo "created $MYDEV"
diskutil eraseVolume HFS+ "ramdisk-${1}gb" $MYDEV
echo "formatted $MYDEV"

This script creates a ramdisk with the first parameter taken as gigabytes. So runnning ./ramdisk.sh 16 will create a disk with 16 gigabytes and it will be named “ramdisk-16gb” and accessible via /Volumes/ramdisk-16gb. It will show up in finder as mounted volume. To get rid of it simply unmount it with the small icon right to the name.

ATTENTION: Everything stored on this devices will be lost when the mac is turned off or the volume is removed.

$VMGUID = (Get-VM "vm_name").ID
$VMWMProc = (Get-WmiObject Win32_Process | ? {$_.Name -match 'VMWP' -and $_.CommandLine -match $VMGUID})
Stop-Process ($VMWMProc.ProcessId) -Force

#!/bin/zsh
source ./.zshrc

echo "starting local upgrades of homebrew, sdk and nvm\n"

echo "###########################"
echo "# homebrew"
echo "###########################"
# install see https://brew.sh
echo "update installed packages"
brew update
brew upgrade

echo "install packages"
brew install nvm
brew tap buo/cask-upgrade

echo "upgrade casks"
brew cu -ay

brew autoremove
brew cleanup

echo "\n\n\n"
echo "###########################"
echo "# sdk"
echo "###########################"

echo "install sdkman"
# https://sdkman.io/install
#curl -s "https://get.sdkman.io" | bash
sdk selfupdate

echo "update sdkman packages"
sdk update
sdk upgrade

echo "\n\n\n"
echo "###########################"
echo "# nvm"
echo "###########################"
echo "install LTS"
nvm install --lts

echo "\n\n\n"
echo "###########################"
echo "# npm"
echo "###########################"
npm update -g

echo "\n\n\n"
echo "###########################"
echo "done"

Running this keeps most of my system up to date. I only have a few things installed either via AppStore or manually.

But where is the problem and what does this have to do with sudo you ask?

When you have a list of pending updates MacOS will ask you multiple time during a single run of the script for you password because sudo is using a very very short timeout for it. If you want to get rid of that problem run sudo viduso and add the following line after all those Defaults lines you will see in there:

Defaults	timestamp_timeout = -1

This way sudo won’t forget your password in a single session. Of course that -1 could be a problem but for me it isn’t because I always close my terminals when I don’t need them anymore.

You will need the html code you want to use as signature. So have it ready to paste it later.

Got to ~/Library/Mail/V10/MailData/Signatures and check which of the .mailsignature files is the one you want to change. For every signature saved in the mail client there is such a file. Just check the content. Open the right file and replace the html after the header. Everything above that empty line is the header. Here a sample that illustrates this:

Content-Transfer-Encoding: 7bit
Content-Type: text/html;
charset=us-ascii
Message-Id: <12341234-1234-1234-1234-123412341234>
Mime-Version: 1.0 (Mac OS X Mail 16.0 (xxxx))

<old content>

Leave everything as is and replace all text “<old content>” with your new html. Save the file. The right click it and click “Get Info” and there you need to select “Locked”. Otherwise the mail client will overwrite the content and not use it.

With the file locked, open the mail client and you will have your html signature ready to use.

#Apple #MailClient #AppleMailClient #HTMLSignature

Could not kickstart service “com.apple.audio.coreaudiod”: 1: Operation not permitted

This was fixed by the following:

sudo su
rm -rf /opt/homebrew/Caskroom/blackhole-2ch
exit
brew install blackhole-2ch

Another option seems to be to fix the issue with kickstart as described here. But I didn’t try that.

Why Replace the Spring Dependency Management Gradle Plugin?

The Spring Dependency Management Gradle Plugin simplifies dependency management by providing a BOM (Bill of Materials) file that declares dependency versions. However, it can sometimes result in transitive dependency conflicts or inadvertently using outdated versions. By leveraging a version catalog, you gain greater control and flexibility over your project dependencies.

Creating a Version Catalog

Start by creating a libs.versions.toml file in the gradle folder of your project. This file will serve as your version catalog, containing sections for versions, libraries, and plugins. Here’s how it might look:

[versions]
# libs
flyway = "10.8.1" # https://mvnrepository.com/artifact/org.flywaydb/flyway-core
# plugins
spring-boot = "3.2.3" # https://spring.io/projects/spring-boot
kotlin = "1.9.22" # https://kotlinlang.org/docs/releases.html#release-details
sonarqube = "4.3.1.3277" # https://plugins.gradle.org/plugin/org.sonarqube

[libraries]
org-flywaydb-core = { module = "org.flywaydb:flyway-core", version.ref = "flyway" }
org-flywaydb-database-postgresql = { module = "org.flywaydb:flyway-database-postgresql", version.ref = "flyway" }

[plugins]
org-springframework-boot = { id = "org.springframework.boot", version.ref = "spring-boot" }
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
kotlin-jpa = { id = "org.jetbrains.kotlin.plugin.jpa", version.ref = "kotlin" }
sonarqube = { id = "org.sonarqube", version.ref = "sonarqube" }

Integrating Version Catalog in Gradle

Now, let’s integrate the version catalog into your Gradle build using Kotlin DSL.

plugins {
    alias(libs.plugins.org.springframework.boot)
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.kotlin.spring)
    alias(libs.plugins.kotlin.jpa)

    alias(libs.plugins.sonarqube)
    jacoco
}

...

dependencies {
    implementation(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
    implementation("org.springframework.boot:spring-boot-starter-actuator")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.springframework.boot:spring-boot-starter-web")

    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")

    implementation(libs.org.sonarsource.sonar.ws)
    implementation(libs.swagger.annotations.v3)

    runtimeOnly("org.postgresql:postgresql")
    runtimeOnly(libs.org.flywaydb.core)
    runtimeOnly(libs.org.flywaydb.database.postgresql)

    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("org.springframework.boot:spring-boot-testcontainers")
    testImplementation("org.testcontainers:junit-jupiter")
    testImplementation("org.testcontainers:postgresql")
}

So all versions are either coming from the Spring Boot BOM that is imported first or from the libs.versions.toml file which is taken in account automatically.

Conclusion

Replacing the Spring Dependency Management Gradle Plugin with a version catalog provides a cleaner and more flexible approach to dependency management in your Spring projects. By centralizing your dependency versions in a separate file, you gain more control and avoid potential conflicts or outdated versions. Give it a try in your next Spring project and experience smoother dependency management firsthand. Happy coding!

#!/usr/bin/env bash

if [[ "" == "$@" ]]; then
    echo "usage: $0 <file(s) to convert>"
    exit 1
fi

for i in "$@"; do
    directory=$(realpath $(dirname "$i"))
    file=$(basename "$i")
    name=${file%.*}
    extension=$(echo ${file##*.} | tr '[:upper:]' '[:lower:]')

    if [[ "$extension" == "psd" ]]; then
        target="$directory/$name.png"
        if [[ -e "$target" ]]; then
            echo "file already exists: '$target'"
        else
            echo "converting '$i'"
            convert "$i" -background none -flatten "$target" || exit 1
        fi
    fi
done

This takes the file(s) to convert as argument(s). You can also just go with wildcards like *.psd to convert all psd files in a folder. Already converted files will be skipped.

You need ImageMagic installed on your machine to have access to the convert command.

Tested with ImageMagic 7.1.1-27 on MacOS Sonoma 14.3.1.