django-htmx VS Alpine.js

If you don't already, you should use django-htmx. This will allow you to check if the request was made with HTMX. You can then do something like this:

To make things easier, install the django-htmx package. Then, in your Page model's serve(), you can do things like if request.htmx: and return an HTML snippet instead of the full page in that case.

The great thing about HTMX is it fits really nicely with templated server-rendered frameworks like Django.

You can have a page with a list of items. The page is one template, and it includes a sub-template which is just the

items. Then you have a separate view for "get list fragment" which just returns the updated/sorted/filtered

. If you toggle the ordering, or filter the list, HTMX will automatically call the fragment renderer and replace just the

items, without reloading the page.

See this example: https://github.com/adamchainz/django-htmx/blob/8054f049f53f0...

This approach solves the common interactivity use-cases requiring JS in a server-rendered app, without having to write any JS, and without having to build a REST API. Instead you just render HTML, which your framework is excellent at.

If you use django-htmx, it's pretty simple to get the "this HTTP request came from HTMX" flag and branch accordingly in your view. The docs give a simple example of the logic here:

https://django-htmx.readthedocs.io/en/latest/middleware.html...

The examples give a fleshed-out version: https://github.com/adamchainz/django-htmx/blob/main/example/...

Though that's very slightly different than how I described it above, but it's basically the same idea; in this case you commonize the `main` block between the two contexts.

HTMX has a HX-Trigger response header that enables you to trigger events in the browser that Javascript code can listen for. Assuming you already have Django-HTMX library set up, you could write a middleware like this:

Nice. I've written some less complete, less consistent variant of this a couple times now. That alone may be worth taking the dependency.

Full URL for django-htmx: https://github.com/adamchainz/django-htmx (creator here)

I think it's fair to clarify that Adam Johnson (aka adamchainz on Reddit and GitHub) didn't create HTMX but did write the django-htmx app to make it easier to use HTMX in Django.

django-htmx also comes with it's own version of HttpResponseHtmxRedirect (called HttpResponseClientRedirect).

Alpine.js for reactive frontend

✨ In recent months, I have been developing web projects using GOTTHA stack: Go + Templ + Tailwind CSS + htmx + Alpine.js. As soon as I'm ready to talk about all the subtleties and pitfalls, I'll post it on my social networks.

> But honestly, torn towards htmx but undecided.

We are in the middle of migrating from our monster react application into server rendered pages (with jinja2). The velocity at which we are able to ship and the reduction of complexity has been great so far.

Managing client side state for simple things like (is the dropdown open/closed), listening to keyboard events and such can be done with something like alpine-js [1] without all the baggage that something like react brings.

It appears this is already the trend with JS frameworks too - with server side rendering being the new norm.

[1] https://alpinejs.dev/

Sure, you can use any number of JS-avoidance libraries. I'm a fan of Turbo, and there's also htmx, Unpoly, Alpine, hyperscript, swup, barba.js, and probably others.

Direct DOM, but with a library. Specifically AlpineJS since it follows Vue closely in design practices allowing me to scale into a full web application if necessary (basically swapping to Vue takes minimal work). The Morph plugin is specifically what I like using.

If you want more details on the initial setup I encourage you to take a look at the Part I that covers more of the initial implementation. For this portion, I added Prisma as an ORM, a frontend style library called Tachyons, and AlpineJS to handle any client-side interactions. I did this to avoid needing to add a client-side bundler to the build and instead just rely on plain old module imports to compose the frontend. This is now the default for Rails and it is quite nice to not need any additional build tools for the client.

- [swallow-pywebview](https://github.com/rangwea/swallow-pywebview)： Base on [pywebview](https://pywebview.flowrl.com/) using Python，the frontend base on [alpinejs](https://alpinejs.dev/) and [tailwindcss](https://tailwindcss.com/)。

If you’ve followed our other tutorials, you might be familiar with Alpine.js. It’s a lightweight JavaScript library that allows you to add interactivity to your site without writing a single line of JavaScript. It’s incredibly easy to use, and we’ll show you how to make the animation trigger when the user scrolls to it.

The approach is not new, essentially a variation of Knockout, Alpine, and similar "JS-in-HTML" approaches.