Building djinit: Let’s Stop Wasting Time on SetupPermalink to “Building djinit: Let’s Stop Wasting Time on Setup”

Starting a new Django project is… well, kind of a chore. You love Django, I love Django, but setting up the same old folder structure, configuring DRF, and fighting with CORS headers for the 100th time? Not fun.

That’s why I built djinit. It started as a personal tool just for me, to stop the boring copy-paste cycle and get straight to the code. I’ll share why I built it and how it can make your life easier.

Why I Built ItPermalink to “Why I Built It”

I built djinit because I was tired. Every time I started a new idea, I had to do the same manual work:

1. Split Settings: Creating base.py, dev.py, and prod.py manually.
2. API Setup: Installing Django REST Framework and setting up all the parsers.
3. Auth: Wiring up JWT authentication so users can actually log in.
4. CORS: Fixing those annoying cross origin errors that block the frontend.
5. Docs: Setting up Swagger so I could see my API endpoints.
6. Deployment: Writing Procfile and requirements.txt for the server.

I wanted a tool that works like a smart assistant: I answer a few questions, and it builds the foundation.

How It WorksPermalink to “How It Works”

djinit is a Python CLI tool built with typer and rich. You answer a few prompts and it scaffolds the whole project.

When you run it, it asks:

1. “What structure?”, “Which database?”, “Want Tailwind, HTMX, or Vite?”, “CI/CD pipeline?”
2. It generates all the folders, files, and configuration.
3. It sets up dependencies with uv sync or pip install.
4. You get a project that runs immediately.

What You GetPermalink to “What You Get”

When you run djinit setup, you don’t get a blank folder. You get:

• Ready to Go Settings: Development and production settings are already split and configured with # noqa comments so linters don’t complain.
• API Ready: Django REST Framework is installed and set up with JWT authentication.
• Auto Documentation: Swagger UI at /docs/ and ReDoc at /schema/ thanks to drf-yasg.
• No CORS Headaches: Handled for dev and locked down for production.
• Database Choice: PostgreSQL or MySQL, with DATABASE_URL or individual env vars.
• Production Ready: WhiteNoise for static files, Gunicorn config, and a Dockerfile included.
• Dev Tools: A Justfile with common commands, ruff for linting, pytest for testing.
• CI/CD: GitHub Actions and/or GitLab CI pipelines generated on request.

Optional Add-onsPermalink to “Optional Add-ons”

Beyond the basics, djinit now asks if you want frontend tooling:

• Tailwind CSS - Scaffolded with django-tailwind-cli, DaisyUI theme, and Node.js install in Docker.
• HTMX - django-htmx app and middleware wired into your settings.
• Vite - django-vite with a vite.config.ts, dev/prod mode toggles, and a CI build step.

Pick any combination, or none at all.

How to Use ItPermalink to “How to Use It”

Getting started is easy.

A small heads up: I wanted to name the package djinit, but PyPI said that name was taken. Install it as djinitx.

pipx install djinitx

# or

uv tool install djinitx

# or

pip install djinitx

Once installed, you can use the name djinit (or just dj) in your terminal:

djinit setup

# or simply

dj setup

Pick Your StylePermalink to “Pick Your Style”

Every project is different, so djinit lets you choose the structure that fits:

1. Standard: The classic Django layout we all know.
2. Single Folder: Keep it simple. All your apps live in one folder.
3. Predefined: Great for bigger projects. It separates apps/ and api/.
4. Unified: Clean and minimal. Everything lives under core/ and apps/.

Add AppsPermalink to “Add Apps”

Need to add a users app or a products app? Don’t create folders manually. Just tell djinit:

djinit app users products

It creates the apps, adds them to INSTALLED_APPS, and wires up the URL includes.

Generate Secret KeysPermalink to “Generate Secret Keys”

Need a Django secret key? Don’t search online for random generators:

dj secret

This generates a secure 50 character secret key. Need more keys or a different length?

dj secret --count 5        # Generate 5 keys
dj secret --length 64      # Generate a 64 character key
dj secret --count 3 --length 32  # 3 keys, each 32 characters

Important Note: djinit builds the house, but you have to put the furniture in it. It sets up the structure and configuration, but it does not write your business logic, models, or views. That fun part is still all yours!

What’s ChangedPermalink to “What’s Changed”

Since the initial release, djinit has grown a lot:

• Docker Support - Auto-generates a Dockerfile with multi-stage builds and Node.js for frontend tools.
• Frontend Tooling - Tailwind CSS, HTMX, and Vite integration are now live, not just plans.
• CI/CD Pipelines - GitHub Actions and GitLab CI templates that match your project.
• Dependency Management - uv native support with pyproject.toml and [dependency-groups].
• Dev Dependencies - ruff, pytest, and pytest-django included out of the box.
• API Docs - Switched from drf-spectacular to drf-yasg.
• Django 6.0 - Supports Django 5.1, 5.2, and 6.0.

Future PlansPermalink to “Future Plans”

I am not done yet! Here is what is on my wishlist:

1. Celery Integration: Making background tasks easier to set up.
2. Frontend Scaffolding: Generating React or Vue starter projects alongside the Django backend, not just config.
3. More Packages: Integrating other popular packages to help you build feature-rich apps.

Give it a try. If it saves you even 10 minutes of configuration hell, it did its job.

Happy Coding!