In Ticket 34521 I originally proposed adding Python’s __slots__ to many classes in Django’s template engine. That change was not merged because using slots prevents setting new attributes on objects – something that some external tools rely on. For example:

1. Django Debug Toolbar patches RequestContext to track context processor output.
2. django-template-partials patches the Parser to add tracking of partials.

This proposal is a more targeted approach: add slots only to Django’s internal Node class, all its subclasses, and NodeList. This strategy should balance extensibility with performance because:

• These objects are very numerous – a full page render might involve around a thousand nodes.
• Nodes are more internal than objects like RequestContext or Parser, making unexpected attribute additions less likely.
• Custom template tags creating their own Node subclasses will not be auto-slotted without explicitly defining slots, so they continue to work as before.

I created a draft PR demonstrating this change. The benchmark results on a real-world client project with 601 templates show a ~20% memory reduction (from 14.29 MiB to 11.51 MiB) and a ~6% speedup in rendering. I used the following script with tracemalloc to measure memory usage:

PYTHONCopied
import os
import time
import tracemalloc
import warnings
from pathlib import Path

from django.template import Context, engines

# Ignore all warnings as some templates trigger them
warnings.simplefilter("ignore")

engine = engines["django"]

tracemalloc.start()

templates = {}
for dir_ in engine.template_dirs:
    dir_ = Path(dir_)
    for root, _, files in os.walk(dir_):
        root = Path(root)
        for file in files:
            template_name = str((root / file).relative_to(dir_))
            if template_name in templates:
                continue

            try:
                templates[template_name] = engine.get_template(str(template_name))
            except Exception:  # some TemplateSyntaxErrors
                pass

print(f"{len(templates)} templates loaded")

snapshot = tracemalloc.take_snapshot()
tracemalloc.stop()
total_bytes = sum(
    stat.size for stat in snapshot.statistics("lineno")
)
print(f"Total memory allocation: {total_bytes / 1024 / 1024:.2f}MiB")

Invoked like:

BASHCopied
$ ./manage.py shell -c 'import example'
601 templates loaded
Total memory allocation: 14.29MiB

For benchmarking rendering speed, I used pyperf. The benchmark command was:

BASHCopied
$ python -m pyperf timeit \
    --setup 'import django\ndjango.setup()\nfrom django.template import Template, Context\ntemplate = Template("it is {{ x }}\n" * 100_000)\ncontext = Context({"x": "X"})' \
    'template.render(context)' \
    --inherit-environ DJANGO_SETTINGS_MODULE \
   --rigorous \
   --duplicate 10

I ran the benchmark on both Django’s main branch (output saved as before.json) and on my modified branch (saved as after.json). The results:

BASHCopied
$ python -m pyperf compare_to before.json after.json --table
+-----------+--------+----------------------+
| Benchmark | before | after                |
+===========+========+======================+
| timeit    | 183 ms | 172 ms: 1.06x faster |
+-----------+--------+----------------------+

This statistically valid 6% speedup supports the case for adopting slots on these internal classes. What are your thoughts on this proposal?