Visual Studio Code with Calva

Visual Studio Code with Calva is a strong option when you want a lighter editor than IntelliJ but still want a real Clojure workflow instead of just syntax coloring. The key point is that Calva is not merely a language plugin. It is a REPL-oriented development layer for VS Code.

Why Calva works

The official Calva docs center everything around connection to a running REPL. That is the correct emphasis. In Clojure, the editor is useful because it is connected to a live process, not because it can color brackets.

Calva gives you:

• jack-in workflows for starting a REPL from the editor
• evaluation of forms and namespaces
• REPL output and interactive feedback
• project-aware workflows for Clojure and ClojureScript
• integration with modern VS Code ergonomics instead of a heavyweight IDE shell

For Java developers who already like VS Code, that makes Calva the main thing you need to turn the editor into a serious Clojure environment.

Start with jack-in, not manual wiring

The official docs recommend jack-in, and that is the right default. Calva uses the project REPL connection not only for evaluation, but also for IDE behavior that depends on runtime knowledge of the project.

The docs also make clear that jack-in supports both CLJ and CLJS, with built-in configurations for projects using Leiningen, deps.edn, shadow-cljs, and Gradle.

That matters because a Java developer should not waste early time manually reconstructing the REPL command line if the editor can do it correctly for you.

A practical baseline workflow is:

1. open the project root in VS Code
2. run Calva: Start a Project REPL and Connect (aka Jack-in)
3. choose the project type Calva detects
4. evaluate a few forms and confirm the namespace is live
5. only customize further once this loop works reliably

Environment problems are often really shell problems

One of Calva’s more practical documentation notes is easy to miss: if your environment variables live in shell startup files, VS Code may need to be launched from a shell that already has those variables defined.

For Java developers, this often shows up as:

• the wrong JDK being used
• clojure, bb, or node not being found
• project-specific environment variables missing during jack-in

If jack-in behaves strangely, check the environment before blaming Calva itself.

What Calva is best at

Calva is strongest when you want:

• VS Code’s lighter feel
• terminal/task visibility during startup
• a good Clojure/ClojureScript loop without moving to Emacs
• a workflow you can keep close to other polyglot projects already opened in VS Code

It is especially attractive for developers who already work in VS Code for TypeScript, Python, Go, or Terraform and want to keep one editor without giving up the REPL.

What Java developers should not miss

The biggest mistake Java engineers make with Calva is treating it like a plain text editor plus extension bundle. It works best when you actively use the REPL.

That means learning habits such as:

• evaluating the current form instead of rerunning the whole program
• loading namespaces deliberately
• reading REPL output as part of normal work
• keeping project startup and runtime wiring understandable

If you do not use those habits, you will get only a fraction of what Calva offers.

When Calva is the right choice

Choose Calva when you want a modern, lighter editor and you are comfortable relying on the REPL as the center of development. If you want the deepest Java-IDE feel, Cursive is usually stronger. If you want maximum editor programmability, Emacs may win. Calva sits in the middle and is often the best compromise.

Knowledge Check