clojurescript.org

What is ClojureScript?

ClojureScript is a compiler for the Clojure language that targets JavaScript. You write Clojure — a functional Lisp dialect with immutable, persistent data structures and a macro system — and it emits JavaScript compatible with the advanced compilation mode of the Google Closure optimizing compiler. The pitch on ClojureScript is the combination of three things: JavaScript's reach across browsers and web platforms, Clojure's interactive, functional style, and Closure's whole-program optimization for fast-loading output.

Who it suits

• Clojure developers who need the browser. If your team already writes Clojure on the JVM, ClojureScript lets you reuse the language and its idioms on the client rather than splitting into a second language.
• Teams that value immutable data and pure functions. The site's company quotes, such as Asier Galdos of Greenius describing a design built on immutable structures and pure functions with less code than traditional OO approaches, reflect that emphasis. Those are the companies' observations about their own work, not a benchmark.
• Projects where bundle size and load time matter. Advanced Closure compilation is the reason the project pairs with the Closure compiler; it rewards code written to work with it.

The trade-offs to weigh

A concrete way to decide

Take one self-contained feature — say, a data-heavy dashboard view — and build it in ClojureScript with a small team member who knows Clojure. Judge it on three things: how quickly the person was productive, how the compiled output size compares with your current bundle, and whether the immutable-data approach made the UI state easier or harder to reason about. If the answers favor it, the project's guides and reference material are the natural next stop; if not, the Lisp learning curve is likely to outweigh the benefits for that team.

How does ClojureScript compile to JavaScript and work with the Google Closure compiler?

ClojureScript is a compiler for Clojure that targets JavaScript: you write Clojure code, and it emits JavaScript designed to be compatible with the advanced compilation mode of the Google Closure optimizing compiler. That pairing is the core of how it works—Clojure gives you a functional Lisp with immutable, persistent data structures, interactive development and a macro system, while the output runs wherever JavaScript runs.

How the pieces fit

• Clojure source → JavaScript output. The compiler translates Clojure forms into JavaScript rather than interpreting them, so the result is ordinary JS for browsers and other JS engines.
• Google Closure for whole-program optimization. The emitted code is built to work with Closure's advanced mode, which optimizes across the entire program, including libraries, to keep load times low.
• Why JavaScript at all. The site frames JavaScript's reach across browsers and web applications as unmatched, with heavily optimized engines, which is why ClojureScript targets it instead of a separate runtime.

What this means in practice

A concrete scenario: a team building a large browser application with many dependencies. Writing in ClojureScript lets them use Clojure's data structures and macros, and relying on Closure's advanced compilation helps keep the shipped bundle lean even as libraries accumulate. The trade-off is that the toolchain assumes familiarity with both Clojure idioms and Closure-compatible compilation, so teams coming purely from plain JavaScript face a learning curve on two fronts.

The page lists the current release as 1.12.134. For a practical next step, start with the site's Get Started and Guides walkthroughs at ClojureScript, and check the Reference when you need details on compiler behavior.

Should I choose ClojureScript over plain JavaScript for a new web application?

Choose ClojureScript when your team values immutable data, functional patterns, and a single language across browser and Node.js—and is willing to accept a build step, a smaller hiring pool, and a learning curve. Stay with plain JavaScript (or TypeScript) for small teams, tight deadlines, or heavy reliance on mainstream tooling and tutorials.

Where ClojureScript fits well

ClojureScript is a compiler for Clojure that targets JavaScript and emits code compatible with Google Closure's advanced compilation mode. That means whole-program optimization is a first-class goal, not an afterthought. Practical fits:

• Data-heavy UIs where immutable, persistent data structures simplify state handling.
• Teams already fluent in Clojure who want shared code and mental models between server and browser.
• Long-lived applications where macro support and code-as-data reduce boilerplate.
• Performance-sensitive bundles, since advanced compilation can shrink and optimize large library graphs.

Where plain JavaScript wins

• Hiring and onboarding: far more candidates and learning resources exist for JavaScript/TypeScript.
• Ecosystem fit: most libraries, examples, and Stack Overflow answers assume JS directly.
• Prototyping speed: no compiler setup or interop friction for small projects.
• Debugging familiarity: browser devtools map closely to source without extra configuration.

A practical next step

Build a small feature—say, a filterable list with async data—in both. If the ClojureScript version feels clearer and your team can maintain it, the trade-off is worth it. If interop and setup dominate your time, plain JavaScript or TypeScript is the safer default. The site's own guides and reference are the right starting point for that trial.

What functional programming features and immutable data structures does ClojureScript offer?

ClojureScript's functional core comes from Clojure itself: it is described as a functional language built on a rich set of immutable, persistent data structures, with a code-as-data (Lisp) philosophy and a powerful macro system. It compiles Clojure to JavaScript, so you write functional Clojure-style code that runs on the JS platform, and output is compatible with Google Closure's advanced optimization.

What that means in practice

• Immutable, persistent data structures. Collections are not mutated in place; updates produce new values while sharing structure, so you keep old versions cheaply. This suits undo/history, time-travel debugging, and safe passing of state between components.
• Pure functions as the default style. Logic that transforms data is separated from side effects, which makes it easier to test and reason about. The site's company quotes stress exactly this: Asier Galdos of Greenius describes designing software "with just immutable data structures and pure functions (with much less code than traditional OO languages)."
• Macros and code-as-data. As a Lisp dialect, ClojureScript lets you extend the language itself, so repetitive patterns can become reusable syntax rather than boilerplate.
• Interactive development. Clojure's REPL-driven workflow carries over, letting you evaluate code against a running app.

Trade-offs to weigh

Next step: if you're evaluating it for a browser app, read the Rationale and Guides on ClojureScript and try a small state-heavy feature—such as an undoable form—to feel how persistent data structures change your design. For broader Clojure context, see Clojure.

How do I set up a ClojureScript development environment and start building an app?

Start by installing a JVM-based Clojure toolchain and a Node.js runtime, then create a project with a Clojure build tool that compiles ClojureScript to JavaScript. The official site, ClojureScript, documents the language, reference material and guides; its current release is listed as 1.12.134. The compiler targets JavaScript and emits code compatible with Google Closure's advanced optimization, which is why production builds can be small even with libraries.

A practical setup path

1. Install prerequisites. A JDK (for the Clojure/ClojureScript compiler) and Node.js (for running tooling and a dev server). Check versions with java -version and node -v.
2. Create a project. The common route is a Clojure CLI project with deps.edn and a build configuration (for example with shadow-cljs or the official cljs.main workflow). Pick one build tool and stay with it while learning.
3. Add a minimal app. One namespace with a main function that mounts a DOM node; one HTML page that loads the compiled output.
4. Run a development build. Start a watch/reload process so edits recompile and the browser refreshes. Open the browser console early; compiler warnings appear there and in the terminal.
5. Build for production. Produce an optimized build (advanced compilation) and serve it, then confirm the page works without the dev server.

Choosing between the two common workflows

If you already use npm packages heavily, the second row usually saves time; if you want to understand exactly what the compiler does, start with the first.

First app to build

A small single-page app is enough to exercise the important parts: a reagent-style component or plain DOM rendering, an atom holding state, and an event handler that updates it. For example, a counter with increment/decrement buttons teaches immutable state updates, rendering, and event wiring without drowning you in setup. Once that works, add a second namespace and a route, then test an optimized build.

A useful next step: read the official guides on ClojureScript for the compiler and reference sections, and keep the community forums at ask.clojure.org open for setup questions. Decision criterion: choose your build tool based on whether npm interop or minimal tooling matters more to your first app, and defer optimizing until the development loop feels fast.

What companies and real-world projects use ClojureScript in production?

ClojureScript's own site names a few companies and projects that use it in production, and those examples point to where the language tends to fit: interactive, browser-heavy applications where a small team wants to ship complex UI logic without a large JavaScript codebase.

Companies and projects named on the site

• Precursor — Danny King, Co-Founder/Designer, describes learning ClojureScript, Om and React as giving him end-to-end ownership of design work. That fits a product team where the same people shape both interface and implementation.
• Greenius — Asier Galdos, Co-founder/developer, says the software was designed with immutable data structures and pure functions, using less code than traditional object-oriented languages, so the team could focus on business requirements rather than technological problems. This is a realistic fit for a small team maintaining a data-driven application.
• An unnamed company quoted as saying "Clojure and Clojurescript are the backbone of our business" — the excerpt is cut off, so treat this as a general signal of production use rather than a named case.

The site's "Companies Succeeding with ClojureScript" section is the place to look for the full list; the excerpt above only captures part of it.

How to judge whether those examples apply to you

The named cases share a pattern: small teams, rich client-side interfaces, and a preference for immutable data over mutable object graphs. If your project is a dashboard, editor, or other stateful browser app maintained by a handful of developers, the trade-offs those teams describe are likely to resemble yours. If you are building a mostly server-rendered site or a large team already fluent in TypeScript, the payoff is less obvious.

As a next step, read the quoted case studies on ClojureScript and compare them with your own team size and UI complexity before committing. For broader production reports beyond this site, the community section linked there is the natural starting point.