htmx VS kotlinx.coroutines

Compare htmx vs kotlinx.coroutines and see what are their differences.


</> htmx - high power tools for HTML (by bigskysoftware)


Library support for Kotlin coroutines (by Kotlin)
Our great sponsors
  • Nanos - Run Linux Software Faster and Safer than Linux with Unikernels
  • Scout APM - A developer's best friend. Try free for 14-days
  • SaaSHub - Software Alternatives and Reviews
htmx kotlinx.coroutines
121 31
4,668 9,975
6.7% 2.3%
9.4 9.0
9 days ago about 19 hours ago
JavaScript Kotlin
BSD 2-clause "Simplified" License Apache License 2.0
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.


Posts with mentions or reviews of htmx. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2021-10-16.
  • Learning Javascript after Python
    Have a look: "> htmx - high power tools for html"
  • The JavaScript ecosystem is a hot mess and so is software development in general | 2021-10-16
    I work on a dependency-free, build-less library called htmx:

    It's more an extension of HTML than a JS library. It might be a good way to gently introduce more dynamic behavior without blowing out the complexity of your site.

  • Should I ditch using Django | 2021-10-16
    As an additional advice, I would check the Django subreddit and ask what are they doing for their front-end needs (e.g. check this one) -> you don't have to use JS for front-end (e.g. check htmx, unicorn, etc).
  • The Decline of Django | 2021-10-15
    I think the case for server-side HTML rendering has never been stronger, and of all Django projects I work on, the ones I enjoy most are those that never got on the SPA bandwagon. From both a developer and user point of view I find them much faster and less painful. There are many cases where you really, really don't need the massive amount of extra complexity involved in designing APIs, adding JS frameworks etc.

    When you need a bit of extra UI goodness, [htmx]( is a fantastic solution, and you can still use SPA-type approaches for things that need them.

    You can also benefit from massively faster (and more reliable) functional testing when you are mostly standard HTML - see [django-functest]( for an example of this.

  • Has anyone written a small framework to support HTMX? | 2021-10-14
  • How Laravel Livewire works (a deep dive) | 2021-10-12
    I recently started using htmx ( in combination with Django and have become a firm believer of sending HTML 'over the wire' instead of JSON structures that then get used client side.
  • I built a modern website in 2021 | 2021-10-10
    Curious - why aren’t simpler frameworks like htmx ( more common or
  • Ask HN: Why aren’t frameworks like htmx more popular? | 2021-10-10
    shifting to htmx [1] or related “simpler” libraries?


  • The Shocking Immaturity of JavaScript | 2021-10-10
    Complexity and instability in the JS ecosystem is a hot button for me, so it's hard not to be drawn into vehement agreement.

    I've been doing a little work recently with htmx[0] and it's a breath of fresh air. But then, I'm at the point in my career where "cool new tech" is much less interesting for its own sake than it used to be when I was younger. I'm drawn for more to elegant, understandable, productive simplicity these days.

    I think that hints at the reason we have these endless debates - not just about JS but about $(your-favourite-tech). Software development is a socio-technical endeavour. We put all the focus on the technical part, and by comparison, rarely consider the social aspect.

    DHH is one of the few I've heard actually refer to this, on the corecursive podcast [1]. In discussing static typing vs dynamic, his point is the latter suits his brain. But that he understands and accepts static typing suits others, and that's fine.

    So I get that, for some, the JS ecosystem is dynamic and interesting; stimulating; exhilarating even. For others, it's an unstable quicksand that gets in the way of doing something useful.



  • Action without refreshing the page? | 2021-10-04


Posts with mentions or reviews of kotlinx.coroutines. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2021-10-01.
  • Updating my tech stack: RxJava vs Flow
    The catch operator ignores CancellationException which is used for cooperative cancellation in coroutines and flows. If you use try/catch, make sure you're not accidentally swallowing those exceptions. The same goes for runCatching, which catches all Throwables.
  • All About Opt-In Annotations | 2021-09-30
    Some of the best examples of opt-in APIs are in first-party Kotlin libraries. A great example is the kotlinx.coroutines library, which uses four different opt-in marker annotations across its API.
  • Our first year with Kotlin Multiplatform | 2021-09-21
    The second one is about the memory model in Kotlin/Native (in our case for iOS), and the possibility of using a background thread for coroutines. This one doesn't have a final implementation yet either, but a final solution is on the way. However, a temporary solution from JetBrains in the form of a special native-mt Coroutines build has proven to be sufficient in not delaying the use of Kotlin Multiplatform any further.
  • Trying out the experimental new Kotlin/Native memory model | 2021-08-07
    It's pretty neat seeing this in action! As the Kotlin team promised previously, existing code written around freeze() in the strict memory model still appears to behave the same in the new experimental model. But we also now have the ability to pass unfrozen things across threads. This should mean that, once the model is finalized, existing code won't need to migrate immediately. However, early adopters of the experimental model will likely need to wait for any concurrency libraries they depend on to update, or else they'll still need to handle the existing freeze() behavior. That work has already begun in kotlinx.coroutines.
  • How We integrated Kotlin Multiplatform Into Profi
    For asynchronous operations, we used kotlinx.coroutines and kotlinx.serialization for the serialization and deserialization processes.
  • What are the things you don't like when working with kotlin? | 2021-07-25
    Now for KMM, it is very much an alpha product even though many companies have found success in its use. The gradle build configuration can be very tricky to do unless you know what you're doing and the templates in intellij are rather limited at the moment of what you can setup in a new project. Kotlin native multithreading is still a rather complicated topic if that is something you need to be stable, but there is an open issue to address this and experimental branches you can use. Now the positive side to KMM is the ability to share logic between every platform and just needing to implement each UI natively. There are also great architecture solutions out there like Decompose which allows you to write a very large portion of your app in kotlin.
  • It is possible to mix Java Future with Kotlin for async? | 2021-06-18
    Maybe this helps ?
  • Kotlin Team AMA #3: Ask Us Anything | 2021-05-27
    for /u/qwwdfsad Coroutines Why don't SharedFlow and StateFlow suspend waiting for all current subscribers to have completely processed the latest value? Will they ever? The docs said so but then when an issue was raised ( the docs were changed instead of the code. :( | 2021-05-27
    We believe that most of "useful operators" that you mention are very domain-specific and are better suited for domain-oriented extension libraries on top of Flow. We've specifically designed Flow to make writing your own operators trivial. However, if you do feel that some general-purpose operators are missing, then please give us feedback at | 2021-05-27
    We have the general compatibility guide regarding experimentality that explains the potential trade-offs and pitfalls. TL;DR it's pretty safe to use in production apps (not libraries that are shipped in binary form for other apps/libs) as long as you are okay with a periodical check of the changelog before coroutines update.

What are some alternatives?

When comparing htmx and kotlinx.coroutines you can also consider the following projects:

Alpine.js - A rugged, minimal framework for composing JavaScript behavior in your markup.

react-snap - 👻 Zero-configuration framework-agnostic static prerendering for SPAs

Turbolinks - Turbolinks makes navigating your web application faster

django-unicorn - The magical reactive component framework for Django ✨

turbo - The speed of a single-page web application without having to write any JavaScript

phoenix_live_view - Rich, real-time user experiences with server-rendered HTML

kotlin-coroutines - Examples for coroutines design in Kotlin

svelte-query - Performant and powerful remote data synchronization for Svelte

intercooler-js - Making AJAX as easy as anchor tags

budibase - Budibase is an open-source low code platform that helps you build internal tools in minutes 🚀

django-htmx - Extensions for using Django with htmx.

django-tables2 - django-tables2 - An app for creating HTML tables