ClojureScript Async/Await: Bridging FP and JavaScript (2026)

On May 7, 2026, ClojureScript 1.12.145 shipped with native async/await support, closing the gap that topped community surveys for years. The new ^:async function hint generates JavaScript async functions directly, eliminating the awkward dance between functional programming principles and JavaScript’s Promise-heavy ecosystem. For a language trying to break into mainstream adoption, speaking JavaScript’s async language matters more than theoretical purity.

The Problem: Promise Hell in Functional Land

Before async/await, ClojureScript developers faced two terrible options when working with JavaScript Promises. Option one: nested .then() callback hell that looked like this:

;; The old way: Nested promise callbacks
(.then (js/fetch "/api/user")
  (fn [response]
    (.then (.json response)
      (fn [user]
        (.then (js/fetch (str "/api/posts/" (:id user)))
          (fn [posts-response]
            ;; Three levels deep and still not done
            ))))))

Option two: Learn core.async’s CSP model and add a dependency just to fetch JSON from an API. Neither option was good for simple async operations—the kind that dominate modern web development.

This mattered because JavaScript’s entire modern ecosystem is Promise-based. Browser APIs, popular libraries like Firebase and Supabase, even Node.js built-ins—all return Promises. As a result, ClojureScript developers were paying a “functional programming tax” every time they interacted with the JavaScript world.

The Community Spoke, The Team Listened

According to the State of Clojure 2025 survey published in February, “support for async functions dominated the list of desired ClojureScript enhancements for JavaScript interop.” Not “was popular” or “came up often”—dominated. When 70% of your community says they’d recommend your language but the #1 complaint is JavaScript interop friction, you listen.

The ClojureScript team delivered exactly what developers asked for. Moreover, the new approach is clean:

;; The new way: Native async/await
(defn ^:async fetch-user-posts [user-id]
  (let [response (await (js/fetch "/api/user"))
        user (await (.json response))
        posts (await (js/fetch (str "/api/posts/" (:id user))))
        post-data (await (.json posts))]
    post-data))

No callbacks. No core.async dependency. Just straightforward Promise handling that any JavaScript developer can read. Furthermore, this is responsive language design—building features based on real developer needs rather than theoretical elegance.

When to Use Async/Await vs core.async

async/await doesn’t replace core.async, and you shouldn’t try to make it. They’re complementary tools for different jobs.

Use async/await when you’re calling Promise-based JavaScript libraries, working with browser APIs like fetch or Web Crypto, or handling simple sequential async operations. In fact, if you’re just fetching data from an API and transforming the response, async/await is the right tool.

Use core.async when you need to coordinate multiple async processes, require channels and queue semantics, or build event-driven architectures. core.async’s CSP model excels at complex coordination patterns that async/await can’t express cleanly. However, don’t pull in core.async if you’re just making HTTP requests. Don’t try to build a complex event system with just async/await. The ClojureScript ecosystem now offers the right tool for each level of complexity.

What This Means for Adoption

ClojureScript has always had a chicken-and-egg adoption problem. The language is fantastic for large codebases once you learn it, but the learning curve and JavaScript friction kept teams from starting. Companies like Nubank, Netflix, and Walmart already use ClojureScript in production, proving it works at scale. Nevertheless, wider adoption has been slow.

async/await removes one major barrier to entry. JavaScript developers already know async/await from ES2017. The syntax is familiar, the semantics are understood, and the cognitive load of evaluating ClojureScript drops significantly. Instead of explaining how core.async works or demonstrating callback patterns, you can show code that looks like JavaScript—because it compiles to JavaScript async functions.

Consequently, language adoption isn’t just about technical merit. It’s about reducing friction at every step: learning, hiring, integration with existing tools. async/await makes the first step—trying ClojureScript—significantly easier for the 90% of developers who already know JavaScript.

Pragmatism Over Purity

Some functional programming purists might question whether async/await—a fundamentally imperative construct—belongs in a functional language. The ClojureScript team chose pragmatism over dogma, and the community response has been overwhelmingly positive. The Hacker News discussion this week showed general approval, with developers saying “this closes the gap with JavaScript.”

This represents a broader trend in functional programming. Languages that succeed are those that adapt to real-world needs without compromising core principles. ClojureScript still has immutability, pure functions, and data-oriented design. It just also has async/await when you need it. That’s smart evolution, not compromise.

Key Takeaways

• ClojureScript 1.12.145 adds native async/await through the ^:async function hint
• This was the #1 requested feature from the State of Clojure 2025 survey
• Use async/await for Promise interop, core.async for complex coordination patterns
• The familiar syntax significantly lowers the barrier for JavaScript developers evaluating ClojureScript
• Pragmatic language evolution beats theoretical purity when it serves real developer needs