Python's Global Interpreter Lock is universally maligned. It prevents multiple threads from executing Python bytecode simultaneously, forcing sequential execution of parallel code. The community has spent two decades fighting it, working around it, and finally removing it. PEP 703 delivered free-threaded Python. The constraint was lifted.
Note (2026-11-13; read against the paper's full text): the paper's results are broader than the essay's two-sided account. The up-to-4x speedup is for parallelizable workloads on independent data, and it also reports that workloads where threads frequently access and modify the same objects show reduced improvement or even degradation from lock contention. It reports that energy is proportional to execution time in every workload, so the 13 to 43 percent energy increase for sequential kernels is the same factor as the increase in execution time. Memory rises generally, more in virtual than in physical memory, and the paper attributes this mainly to per-object locking, additional thread-safety mechanisms and a new memory allocator. I did not find the essay's list of reference-count synchronization and cache coherence traffic as measured causes of the sequential energy cost; the paper cites PEP 703's changes to reference counting as part of the overhead but does not measure them separately. That sequential code is the majority of Python code is the essay's statement; the benchmarks are kernels such as sorting and prime sieves.
Montoya Salazar (arXiv:2603.04782) measured what the removal actually costs. Parallel workloads gain up to 4x speedup — the promised benefit, delivered. But sequential workloads — the majority of Python code — increase energy consumption by 13 to 43 percent. Memory usage rises across the board. The lock was not just preventing parallelism. It was preventing the overhead of parallelism-readiness.
The GIL's monopoly on the interpreter eliminated an entire category of bookkeeping: reference count synchronization, fine-grained locking of data structures, cache coherence traffic between cores. These costs are zero when a single lock serializes everything. They are nonzero when each object must be independently thread-safe, even if no second thread ever touches it.
The constraint was also an optimization. Not incidentally — structurally. The simplification that prevented parallel execution also prevented the overhead that parallel-safe execution requires. Removing the constraint doesn't give you free performance in the general case. It gives you a new cost that was previously hidden behind the limitation.
The community wasn't measuring the right thing. The metric was “how much faster could parallel code run?” The unmeasured cost was “how much more energy does sequential code consume when the infrastructure for parallelism exists but isn't used?” The answer is 13-43 percent. The GIL was paying that bill by making parallelism impossible.