2025 was a rich year for the Python ecosystem. Python 3.14 was released on October 7, 2025, and Django 5.2 was released as a long-term support (LTS) version on April 2, 2025. Together, these two releases meaningfully improve the experience of building back-ends with Python. In this article we review the most important changes in both.

Python 3.14: The Official End of the GIL Restriction

The headline news of this release is the official support for Free-threaded mode (no GIL) based on PEP 779. The Global Interpreter Lock prevented true parallelism of threads across multiple cores for years. Now this capability is fully implemented and officially supported—although the free-threaded interpreter is still not installed by default and must be enabled separately. This change is a milestone for CPU-bound work and parallel processing.

Template Strings (t-strings)

Python 3.14 introduces a new kind of string called t-strings. Unlike f-strings, which are immediately converted into a string, t-strings return a processable object that keeps the constant parts and interpolated values separate. This is extremely useful for building safe queries, injection-free HTML, and similar scenarios.

name = "<script>"
template = t"Hello {name}"
# template is a Template object, not a raw string;
# values can be escaped or validated before final rendering

Other Python 3.14 Highlights

Several other important improvements are included in this release. Deferred evaluation of annotations reduces runtime overhead. The new compression.zstd module provides built-in support for the Zstandard compression algorithm. The interactive PyREPL now has syntax highlighting, and command-line tools such as argparse, json, unittest, and calendar support color. A zero-overhead external debugger interface for CPython has also been added, making profiling and debugging tools more powerful.

Django 5.2 LTS: Composite Primary Keys

Django 5.2 is an LTS release and receives security updates for at least three years (until April 2028), making it a safe choice for production projects. The most important new feature is support for composite primary keys via the new CompositePrimaryKey class. This lets you build tables whose primary key consists of multiple fields—though for now it does not work with the admin panel or as a target for foreign keys.

from django.db import models

class OrderItem(models.Model):
    pk = models.CompositePrimaryKey("order_id", "product_id")
    order_id = models.IntegerField()
    product_id = models.IntegerField()
    quantity = models.PositiveIntegerField()

Automatic Model Imports in the Shell

A small but very handy feature is automatic model imports in the shell command. You no longer need to import models manually; Django makes all models from installed apps available automatically.

python manage.py shell
>>> User.objects.count()  # no need to import User

Other Django 5.2 Changes

Customizing BoundField is now easier and can be set at the form, field, or project level. MySQL connections now use the utf8mb4 character set by default (instead of utf8, which was an alias for the deprecated utf8mb3), which matters for full Unicode and emoji support. Also, response.text now returns the string representation of the response body, making it easier to write tests. An important upgrade note: Django 5.2 supports Python 3.10 through 3.14, and the minimum supported PostgreSQL version is 14.

Conclusion

The combination of Python 3.14 and Django 5.2 LTS provides a modern, stable foundation for back-end development. Official free-threading opens a new horizon for true parallelism, t-strings are a safe tool for building dynamic strings, and on the Django side, composite keys and LTS status make it attractive for serious projects. It’s recommended to start new projects on Django 5.2, and to test the compatibility of your C-extension libraries before using free-threaded mode.