• 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())
}

@Configuration
class RestCorsConfig : WebMvcConfigurer {

    override fun addCorsMappings(@NonNull registry: CorsRegistry) {
        registry.addMapping("/**")
            .allowedMethods(HttpMethod.GET.name(), HttpMethod.POST.name(), HttpMethod.DELETE.name())
            .allowedOrigins("*")
    }
}

This allows access to all endpoints from all origins via GET, POST and DELETE methods.

version: "3.9"
services:

  postgres:
    image: postgres:15-alpine
    container_name: postgres
    hostname: postgres
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - postgres:/var/lib/postgresql/data/pgdata:rw
    ports:
      - "127.0.0.1:5432:5432"
    environment:
      POSTGRES_DB: db
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: admin
      PGDATA: /var/lib/postgresql/data/pgdata
      TZ: UTC
      PGTZ: UTC
    healthcheck:
      test: [ "CMD-SHELL", "pg_isready -U admin -d db" ]
      interval: 1s
      timeout: 5s
      retries: 10

volumes:
  postgres:

idea.max.intellisense.filesize=50

Taken from https://www.jetbrains.com/help/objc/configuring-file-size-limit.html this does the following:

The maximum size for files where AppCode enables coding assistance and design-time code inspection, is controlled by the idea.max.intellisense.filesize property. The default value is 2500 kilobytes.

After setting this to 50 the indexing issue was gone. Setting it back to 2500 or even higher made the issue also reappear. Having that indexing starting over and over again was really annoying and also making code completion suck because displayed suggestions disappeared faster than I was able to select them.

Going to revisit this and give an update as soo as I have a better solution or the issue was fixed.

import org.junit.jupiter.api.BeforeAll
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.DynamicPropertyRegistry
import org.springframework.test.context.DynamicPropertySource
import org.testcontainers.containers.GenericContainer
import org.testcontainers.containers.wait.strategy.HostPortWaitStrategy

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
abstract class RedisTest {
    companion object {
        private const val REDIS_IMAGE = "redis:7-alpine"
        private const val REDIS_PORT = 6379

        private const val REDIS_CONFIG_HOST = "spring.data.redis.host"
        private const val REDIS_CONFIG_PORT = "spring.data.redis.port"

        private val redisContainer = GenericContainer<Nothing>(REDIS_IMAGE).apply {
            withExposedPorts(REDIS_PORT)
            withReuse(true)
        }

        @JvmStatic
        @BeforeAll
        fun beforeAll() {
            if (!redisContainer.isRunning) {
                redisContainer.start()
                redisContainer.setWaitStrategy(HostPortWaitStrategy())
            }
        }

        @JvmStatic
        @DynamicPropertySource
        fun properties(registry: DynamicPropertyRegistry) {
            registry.add(
                REDIS_CONFIG_HOST,
                redisContainer::getContainerIpAddress
            )
            registry.add(
                REDIS_CONFIG_PORT,
                redisContainer::getFirstMappedPort
            )
        }
    }
}

With this in place you can create a simple test by extending RedisTest

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.data.redis.core.RedisTemplate

class EventSourceTest @Autowired constructor(
    val redisTemplate: RedisTemplate<String, String>
) : RedisTest() {

    @ParameterizedTest
    @CsvSource(
        value = [
            "test1, 1",
            "test2, 2",
            "test3, 3",
        ]
    )
    fun redis(
        key: String,
        value: String
    ) {
        redisTemplate.opsForValue().set(
            key,
            value
        )
        assertThat(redisTemplate.opsForValue().getAndDelete(key)).isEqualTo(value)
    }

}

Here a simple code sample for generic Crud events in a JPA application:

open class CrudEvent<ID : Serializable, T : AbstractEntity<ID>>

@EventListener
fun onEvent(event: CrudEvent<UUID, User>) {}

Looks good, right? But doesn’t work. You could replace CrudEvent<UUID, User> with CrudEvent<*, *> and it would start receiving events. But of course all and not just for User. Here a simple way to get around this problem:

class UserEvent: CrudEvent<UUID, User>

@EventListener
fun onEvent(event: UserEvent) {}

    implementation("org.springframework.boot:spring-boot-starter-security")
    implementation("org.springframework.security:spring-security-oauth2-client")

In your config you need to configure the OIDC server:

spring:
  security:
    oauth2:
      client:
        registration:
          keycloak:
            client-id: <id>
            client-secret: <secret>
            authorization-grant-type: client_credentials
        provider:
          keycloak:
            token-uri: <server-url>/realms/<realm>/protocol/openid-connect/token

In the method you create your WebClient you need to add an oauth filter:

    @Bean
    @Qualifier("keycloak")
    @ConditionalOnMissingBean
    fun keycloakWebClient(
      clientRegistrations: ReactiveClientRegistrationRepository,
      authorizedClientService: ReactiveOAuth2AuthorizedClientService,
    ): WebClient {

        val oauth = ServerOAuth2AuthorizedClientExchangeFilterFunction(
                AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager(
                        clientRegistrations, authorizedClientService
                )
        );
        oauth.setDefaultClientRegistrationId("keycloak");

        return WebClient.builder()
            .exchangeStrategies(ExchangeStrategies
                .builder()
                .codecs { clientDefaultCodecsConfigurer: ClientCodecConfigurer ->
                    clientDefaultCodecsConfigurer.defaultCodecs()
                        .jackson2JsonEncoder(Jackson2JsonEncoder(jsonMapper, MediaType.APPLICATION_JSON))
                    clientDefaultCodecsConfigurer.defaultCodecs()
                        .jackson2JsonDecoder(Jackson2JsonDecoder(jsonMapper, MediaType.APPLICATION_JSON))
                }.build()
            )
            .filter(WebClientLoggerBuilder.logRequest())
            .filter(oauth)
            .build()
    }

This results in a WebClient instance using OAuth2 authentication with the server you configured for all calls you use it for. The mapping “keycloak” refers to the key “keycloak” in your application.yml’s spring.security.oauth2.client.registration and spring.security.oauth2.client.provider.

import com.fasterxml.jackson.databind.ObjectMapper
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.http.MediaType
import org.springframework.http.codec.ClientCodecConfigurer
import org.springframework.http.codec.json.Jackson2JsonDecoder
import org.springframework.http.codec.json.Jackson2JsonEncoder
import org.springframework.web.reactive.function.client.ExchangeStrategies
import org.springframework.web.reactive.function.client.WebClient

@Configuration
class WebClientConfig(
    private val jsonMapper: ObjectMapper,
) {

    @Bean
    @ConditionalOnMissingBean
    fun genericWebClient(): WebClient {
        return WebClient.builder()
            .exchangeStrategies(ExchangeStrategies
                .builder()
                .codecs { clientDefaultCodecsConfigurer: ClientCodecConfigurer ->
                    clientDefaultCodecsConfigurer.defaultCodecs()
                        .jackson2JsonEncoder(Jackson2JsonEncoder(jsonMapper, MediaType.APPLICATION_JSON))
                    clientDefaultCodecsConfigurer.defaultCodecs()
                        .jackson2JsonDecoder(Jackson2JsonDecoder(jsonMapper, MediaType.APPLICATION_JSON))
                }.build()
            )
            .filter(WebClientLoggerBuilder.logRequest())
            .build()
    }
}

This defines a bean genericWebClient with Spring Boot configured Jackson ObjectMapper instance.

Here is also the code for the WebClientLoggerBuilder:

import org.springframework.web.reactive.function.client.ClientRequest
import org.springframework.web.reactive.function.client.ExchangeFilterFunction
import reactor.core.publisher.Mono
import java.util.function.Consumer
import org.slf4j.Logger
import org.slf4j.LoggerFactory

object WebClientLoggerBuilder {

    private val log: Logger = LoggerFactory.getLogger(javaClass)

    fun logRequest(): ExchangeFilterFunction {
        return ExchangeFilterFunction.ofRequestProcessor { clientRequest: ClientRequest ->
            if (log.isDebugEnabled) {
                val sb = StringBuilder("Request: \n")
                    .append(clientRequest.method())
                    .append(" ")
                    .append(clientRequest.url())
                    .append("\n")
                clientRequest.headers()
                    .forEach { name: String?, values: List<String?> ->
                        values.forEach(
                            Consumer { value: String? -> sb.append(name).append(": ").append(value).append("\n") })
                    }
                log.debug(sb.toString())
            }
            Mono.just(clientRequest)
        }
    }
}

This simply logs method, path and headers of a request if debug log is enabled and added to the WebClient. Executing a blocking call that parses JSON to a list of objects is then quite easy:

fun <T> queryListWithoutBody(
    path: String,
    listClass: Class<T>,
    params: MultiValueMap<String, String>
): List<T> {
    return webClient.get()
        .uri { it.path(path).queryParams(params).build() }
        .retrieve()
        .bodyToFlux(listClass)
        .collectList()
        .block() ?: emptyList()
}

With this code you’re able to replace RestTemplate without going reactive. Adding spring-boot-starter-webflux also won’t enable netty if you also have good old spring-boot-starter-web in the classpath.

1: Task failed with an exception.
-----------
* What went wrong:
Execution failed for task ':app:processResources'.
> Entry ... is a duplicate but no duplicate handling strategy has been set. Please refer to https://docs.gradle.org/7.5.1/dsl/org.gradle.api.tasks.Copy.html#org.gradle.api.tasks.Copy:duplicatesStrategy for details.

The simple solution is to add the following top level config in your gradle file:

tasks.withType<Copy> {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

Here a summary of commands if you have everything installed and want to bring up minikube with openfaas:

minikube start
arkade install openfaas

# wait until the following command shows all services as ready:
kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"

kubectl rollout status -n openfaas deploy/gateway
kubectl port-forward -n openfaas svc/gateway 8080:8080 &

PASSWORD=$(kubectl get secret -n openfaas basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode; echo)
echo -n $PASSWORD | faas-cli login --username admin --password-stdin

# check if the service answers:
faas-cli list

# print password
echo $PASSWORD

After this you can open http://localhost:8080 with admin user and above printed password.