Django 6.0 Introduction: What's New and Why Choose Django in 2026

# Built-in Background Tasks Framework
# No more Celery dependency for simple background jobs!

from django.tasks import task

@task()
def send_welcome_email(user_id):
    """Send welcome email in background"""
    from django.contrib.auth.models import User
    from django.core.mail import send_mail
    
    user = User.objects.get(id=user_id)
    send_mail(
        'Welcome to Our Platform',
        f'Hello {user.username}, welcome aboard!',
        '[email protected]',
        [user.email],
        fail_silently=False,
    )

# Queue task for background execution
send_welcome_email.enqueue(user_id=123)

# Advanced task with custom queue and priority
@task(queue='high-priority', max_retries=3)
def process_payment(payment_id):
    """Process payment with retries"""
    # Payment processing logic
    pass

process_payment.enqueue(payment_id=456)

# Template Partials - Modular Components
# Define reusable template fragments

# base.html
{% partialdef user_card %}
<div class="user-card">
    <img src="{{ user.avatar }}" alt="{{ user.name }}">
    <h3>{{ user.name }}</h3>
    <p>{{ user.bio }}</p>
</div>
{% endpartialdef %}

# Use partial in same template
{% partial user_card user=current_user %}

# Reuse in different context
{% for member in team_members %}
    {% partial user_card user=member %}
{% endfor %}

# Enhanced Async Support
from django.core.paginator import AsyncPaginator
from django.http import JsonResponse

async def async_product_list(request):
    """Async view with pagination"""
    products = Product.objects.all()
    paginator = AsyncPaginator(products, 20)
    
    page_number = request.GET.get('page', 1)
    page = await paginator.get_page(page_number)
    
    data = {
        'products': [p.to_dict() async for p in page],
        'has_next': page.has_next(),
        'total_pages': paginator.num_pages
    }
    return JsonResponse(data)

# Content Security Policy Support
# settings.py
CSP_DEFAULT_SRC = ["'self'"]
CSP_SCRIPT_SRC = ["'self'", "https://cdn.example.com"]
CSP_STYLE_SRC = ["'self'", "'unsafe-inline'"]
CSP_IMG_SRC = ["'self'", "https:", "data:"]

# New Database Functions
from django.db.models import F, Q
from django.db.models.functions import StringAgg, AnyValue

# StringAgg now works across all backends (not just PostgreSQL)
authors = Book.objects.values('publisher').annotate(
    author_list=StringAgg('author__name', delimiter=', ')
)

# AnyValue returns arbitrary non-null value
recent_orders = Order.objects.values('customer').annotate(
    any_product=AnyValue('product__name')
)

# Enhanced Full Text Search (PostgreSQL)
from django.contrib.postgres.search import Lexeme

# Fine-grained control over search terms
search_query = Lexeme('django') & Lexeme('python')
articles = Article.objects.filter(search_vector=search_query)

# Prefix matching and term weighting
advanced_query = Lexeme('web', prefix=True, weight='A') | Lexeme('framework')

# forloop.length in Templates
# Now available inside {% for %} loops
{% for item in items %}
    <p>Item {{ forloop.counter }} of {{ forloop.length }}</p>
{% endfor %}

# Multiple Cookie Headers Support (HTTP/2)
# Automatic handling when running with ASGI

# Improved GIS Capabilities
from django.contrib.gis.db.models.functions import Rotate

# Rotate geometries by angle
rotated = Location.objects.annotate(
    rotated_geom=Rotate('geometry', angle=45)
)

# Check if geometry has M dimension
locations_with_m = Location.objects.filter(geometry__has_m=True)

# Database Hints for Migration Operations
class Migration(migrations.Migration):
    operations = [
        migrations.AddField(
            model_name='article',
            name='status',
            field=models.CharField(max_length=20),
            hints={'database': 'primary'}  # New in 6.0
        ),
    ]

# JSON Field Negative Indexing (SQLite)
products = Product.objects.filter(data__tags__-1='featured')

# Squashed Migrations Can Be Re-squashed
# Improved migration management for large projects
python manage.py squashmigrations app_name 0001 0010 --squashed

# Generated Fields Auto-Refresh After Save
class Product(models.Model):
    price = models.DecimalField(max_digits=10, decimal_places=2)
    tax_rate = models.DecimalField(max_digits=4, decimal_places=2)
    total = models.GeneratedField(
        expression=F('price') * (1 + F('tax_rate')),
        output_field=models.DecimalField(max_digits=10, decimal_places=2),
        db_persist=True
    )

product = Product(price=100, tax_rate=0.1)
product.save()
print(product.total)  # Automatically refreshed from database

# MODEL: Defines data structure and database interactions
from django.db import models
from django.contrib.auth.models import User

class Article(models.Model):
    """Article model representing blog posts"""
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)
    updated_date = models.DateTimeField(auto_now=True)
    is_published = models.BooleanField(default=False)
    views = models.IntegerField(default=0)
    
    class Meta:
        ordering = ['-published_date']
        indexes = [
            models.Index(fields=['slug']),
            models.Index(fields=['-published_date']),
        ]
    
    def __str__(self):
        return self.title
    
    def get_absolute_url(self):
        from django.urls import reverse
        return reverse('article_detail', kwargs={'slug': self.slug})
    
    def increment_views(self):
        """Increment article view count"""
        self.views = models.F('views') + 1
        self.save(update_fields=['views'])

class Comment(models.Model):
    """Comment model for article comments"""
    article = models.ForeignKey(
        Article, 
        on_delete=models.CASCADE,
        related_name='comments'
    )
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    created_date = models.DateTimeField(auto_now_add=True)
    is_approved = models.BooleanField(default=False)
    
    class Meta:
        ordering = ['created_date']
    
    def __str__(self):
        return f"Comment by {self.author.username} on {self.article.title}"

# VIEW: Handles business logic and request processing
from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.core.paginator import Paginator
from django.db.models import Q, Count

def article_list(request):
    """Display paginated list of published articles"""
    # Query published articles
    articles = Article.objects.filter(
        is_published=True
    ).select_related('author').annotate(
        comment_count=Count('comments')
    )
    
    # Search functionality
    search_query = request.GET.get('q', '')
    if search_query:
        articles = articles.filter(
            Q(title__icontains=search_query) |
            Q(content__icontains=search_query)
        )
    
    # Pagination
    paginator = Paginator(articles, 10)  # 10 articles per page
    page_number = request.GET.get('page', 1)
    page_obj = paginator.get_page(page_number)
    
    # Pass data to template
    context = {
        'page_obj': page_obj,
        'search_query': search_query,
        'total_articles': articles.count()
    }
    
    return render(request, 'articles/list.html', context)

def article_detail(request, slug):
    """Display single article with comments"""
    # Get article or 404
    article = get_object_or_404(
        Article.objects.select_related('author'),
        slug=slug,
        is_published=True
    )
    
    # Increment view count
    article.increment_views()
    
    # Get approved comments
    comments = article.comments.filter(
        is_approved=True
    ).select_related('author')
    
    context = {
        'article': article,
        'comments': comments,
        'related_articles': Article.objects.filter(
            is_published=True
        ).exclude(id=article.id)[:5]
    }
    
    return render(request, 'articles/detail.html', context)

@login_required
def article_create(request):
    """Create new article"""
    if request.method == 'POST':
        form = ArticleForm(request.POST)
        if form.is_valid():
            article = form.save(commit=False)
            article.author = request.user
            article.save()
            return redirect('article_detail', slug=article.slug)
    else:
        form = ArticleForm()
    
    return render(request, 'articles/create.html', {'form': form})

# Async view example
async def api_article_list(request):
    """Async API endpoint for articles"""
    articles = Article.objects.filter(is_published=True)
    
    data = {
        'count': await articles.acount(),
        'articles': [
            {
                'title': article.title,
                'slug': article.slug,
                'author': article.author.username,
                'views': article.views
            }
            async for article in articles[:10]
        ]
    }
    
    return JsonResponse(data)

# TEMPLATE: Renders data for user interface
# articles/list.html
"""
{% extends 'base.html' %}
{% load static %}

{% block title %}Articles{% endblock %}

{% block content %}
<div class="container">
    <h1>Latest Articles</h1>
    
    <!-- Search Form -->
    <form method="get" class="search-form">
        <input type="text" name="q" value="{{ search_query }}" 
               placeholder="Search articles...">
        <button type="submit">Search</button>
    </form>
    
    <!-- Article List -->
    {% if page_obj %}
        <div class="article-grid">
            {% for article in page_obj %}
                <article class="article-card">
                    <h2>
                        <a href="{% url 'article_detail' article.slug %}">
                            {{ article.title }}
                        </a>
                    </h2>
                    <div class="article-meta">
                        <span>By {{ article.author.username }}</span>
                        <span>{{ article.published_date|date:"M d, Y" }}</span>
                        <span>{{ article.views }} views</span>
                        <span>{{ article.comment_count }} comments</span>
                    </div>
                    <p>{{ article.content|truncatewords:50 }}</p>
                </article>
            {% endfor %}
        </div>
        
        <!-- Pagination -->
        <div class="pagination">
            {% if page_obj.has_previous %}
                <a href="?page=1">First</a>
                <a href="?page={{ page_obj.previous_page_number }}">Previous</a>
            {% endif %}
            
            <span class="current-page">
                Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}
            </span>
            
            {% if page_obj.has_next %}
                <a href="?page={{ page_obj.next_page_number }}">Next</a>
                <a href="?page={{ page_obj.paginator.num_pages }}">Last</a>
            {% endif %}
        </div>
    {% else %}
        <p>No articles found.</p>
    {% endif %}
</div>
{% endblock %}
"""

# articles/detail.html
"""
{% extends 'base.html' %}

{% block title %}{{ article.title }}{% endblock %}

{% block content %}
<article class="article-detail">
    <h1>{{ article.title }}</h1>
    
    <div class="article-meta">
        <span>By {{ article.author.username }}</span>
        <span>{{ article.published_date|date:"F d, Y" }}</span>
        <span>{{ article.views }} views</span>
    </div>
    
    <div class="article-content">
        {{ article.content|linebreaks }}
    </div>
    
    <!-- Comments Section -->
    <div class="comments-section">
        <h2>Comments ({{ comments|length }})</h2>
        
        {% for comment in comments %}
            <div class="comment">
                <strong>{{ comment.author.username }}</strong>
                <span>{{ comment.created_date|timesince }} ago</span>
                <p>{{ comment.content }}</p>
            </div>
        {% empty %}
            <p>No comments yet. Be the first to comment!</p>
        {% endfor %}
    </div>
    
    <!-- Related Articles -->
    {% if related_articles %}
        <div class="related-articles">
            <h3>Related Articles</h3>
            <ul>
                {% for related in related_articles %}
                    <li>
                        <a href="{% url 'article_detail' related.slug %}">
                            {{ related.title }}
                        </a>
                    </li>
                {% endfor %}
            </ul>
        </div>
    {% endif %}
</article>
{% endblock %}
"""

# URL Configuration
from django.urls import path
from . import views

urlpatterns = [
    path('', views.article_list, name='article_list'),
    path('<slug:slug>/', views.article_detail, name='article_detail'),
    path('create/', views.article_create, name='article_create'),
    path('api/articles/', views.api_article_list, name='api_article_list'),
]

# E-Commerce Platform
class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    inventory = models.IntegerField()
    
class Order(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    products = models.ManyToManyField(Product, through='OrderItem')
    total = models.DecimalField(max_digits=10, decimal_places=2)
    status = models.CharField(max_length=20)

# Content Management System (CMS)
class Page(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)
    content = models.TextField()
    template = models.CharField(max_length=100)
    is_published = models.BooleanField(default=False)

# Social Networking Platform
class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()
    followers = models.ManyToManyField('self', symmetrical=False)

class Post(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    likes = models.ManyToManyField(User, related_name='liked_posts')

# Data-Driven Dashboard
class Metric(models.Model):
    name = models.CharField(max_length=100)
    value = models.FloatField()
    timestamp = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        indexes = [models.Index(fields=['-timestamp'])]

# API-First Application
from rest_framework import serializers, viewsets

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = '__all__'

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

# Real-Time Chat Application (with Channels)
from channels.generic.websocket import AsyncWebsocketConsumer

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        await self.channel_layer.group_add(self.room_name, self.channel_name)
        await self.accept()
    
    async def receive(self, text_data):
        await self.channel_layer.group_send(
            self.room_name,
            {'type': 'chat_message', 'message': text_data}
        )

# Multi-Tenant SaaS Application
class Tenant(models.Model):
    name = models.CharField(max_length=100)
    domain = models.CharField(max_length=100, unique=True)
    schema_name = models.CharField(max_length=63, unique=True)

class TenantUser(models.Model):
    tenant = models.ForeignKey(Tenant, on_delete=models.CASCADE)
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    role = models.CharField(max_length=50)

# Installation
pip install Django==6.0

# Create new project
django-admin startproject myproject
cd myproject

# Create app
python manage.py startapp myapp

# Add app to settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # Your app
]

# Database configuration (settings.py)
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydb',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

# Run migrations
python manage.py makemigrations
python manage.py migrate

# Create superuser
python manage.py createsuperuser

# Run development server
python manage.py runserver

# Access admin at http://127.0.0.1:8000/admin/

# Quick Start Example
# models.py
from django.db import models

class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title

# admin.py
from django.contrib import admin
from .models import BlogPost

@admin.register(BlogPost)
class BlogPostAdmin(admin.ModelAdmin):
    list_display = ['title', 'created_at']
    search_fields = ['title', 'content']

# views.py
from django.shortcuts import render
from .models import BlogPost

def blog_list(request):
    posts = BlogPost.objects.all().order_by('-created_at')
    return render(request, 'blog/list.html', {'posts': posts})

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.blog_list, name='blog_list'),
]

# Run development commands
python manage.py shell  # Interactive shell
python manage.py test   # Run tests
python manage.py collectstatic  # Collect static files
python manage.py check  # Check for issues