Groovy IDE setup starts with IntelliJ IDEA, VS Code, and Eclipse with step-by-step instructions. Configure syntax highlighting, debugging, and plugins. Tested 2026.

“A craftsman is only as good as their tools – but a great IDE makes every developer look like a craftsman.”

Last Updated: July 2026 | Tested on: Groovy 5.0.6, Java 17 | Difficulty: Beginner | Reading Time: 15 minutes

A proper groovy IDE setup gives you code completion, instant error detection, debugging, and refactoring tools that save hours of work. You can absolutely write Groovy in Notepad and run it from the terminal (grab the latest version from the official Groovy download page), but once you’ve written your first Hello World, a real IDE is the next logical step.

In this guide, I’ll walk you through setting up Groovy in the three most popular IDEs – IntelliJ IDEA, VS Code, and Eclipse. Each setup gives you syntax highlighting, code completion, and the ability to run and debug Groovy scripts in one click.

Already have an IDE? Skip straight to your section. Otherwise, read on – I’ll also help you decide which one is the best fit for your workflow.

The diagram below shows a quick decision tree: start from your installed tools, then branch on whether you already like an IDE and what you plan to build, so you land on the right pick before reading any setup steps:

Tip: click the diagram to open it full screen, then use the zoom and pan controls for a closer look.

What You Need Before Starting

Before setting up any IDE, make sure you have these installed:

• Java 17+ – Groovy 5.0.6 requires Java 17 or higher. Download from Adoptium
• Groovy 5.0.6 – Install via SDKMAN (sdk install groovy) or download from groovy.apache.org

Verify both are working:

Verify Installation

java -version
groovy --version

Output

openjdk version "17.0.11" 2024-04-16 LTS
Groovy Version: 5.0.6 JVM: 17.0.11 Vendor: Amazon.com Inc. OS: Windows 10

If both commands show version numbers, you’re ready to set up your IDE.

Setting Up Groovy in IntelliJ IDEA

IntelliJ IDEA is the gold standard for Groovy development. JetBrains – the company behind IntelliJ – also created the Groovy plugin, so the integration is deep and polished. Both the free Community Edition and the paid Ultimate Edition support Groovy out of the box.

Step 1: Install IntelliJ IDEA

Download IntelliJ IDEA from the JetBrains website. The Community Edition (free) is enough for Groovy work. If you plan to use Grails, the Ultimate Edition has better Grails-specific support.

Step 2: Verify the Groovy Plugin

The Groovy plugin comes pre-installed in IntelliJ. To confirm:

1. Go to File → Settings → Plugins (or IntelliJ IDEA → Preferences → Plugins on Mac)
2. Search for “Groovy” in the Installed tab
3. Make sure it’s enabled

Step 3: Create a Groovy Project

1. Go to File → New → Project
2. Select Groovy from the left panel
3. Set the Project SDK to Java 17+
4. Set the Groovy Library – point to your Groovy installation directory
5. Name your project and click Create

Step 4: Create and Run a Groovy Script

1. Right-click the src folder → New → Groovy Script
2. Name it hello
3. Add your code:

IntelliJ – Test Script

println "Hello from IntelliJ IDEA!"
println "Groovy version: ${GroovySystem.version}"
println "Java version: ${System.getProperty('java.version')}"

Output

Hello from IntelliJ IDEA!
Groovy version: 5.0.6
Java version: 17.0.11

Right-click the file and select Run ‘hello’, or press Ctrl+Shift+F10 (Windows/Linux) or Ctrl+Shift+R (Mac).

IntelliJ Groovy Features You’ll Love

• Smart code completion – understands Groovy closures, GDK methods, and builder patterns
• Inline type inference – shows inferred types even with def
• Groovy Console – built-in REPL at Tools → Groovy Console
• Refactoring – rename, extract method, extract variable all work with Groovy
• Debugging – full breakpoint and step-through debugging
• Grails support – Ultimate Edition has dedicated Grails project type and run configurations

Pro Tip: In IntelliJ, press Ctrl+Shift+A and type “Groovy Console” to open an interactive Groovy shell right inside your IDE. Perfect for testing snippets without creating files.

Setting Up Groovy in VS Code

VS Code is lightweight, fast, and free. While it’s not as deeply integrated with Groovy as IntelliJ, with the right extensions it becomes a perfectly capable Groovy editor – especially for scripting and smaller projects.

Step 1: Install VS Code

Download from code.visualstudio.com. Available for Windows, Mac, and Linux.

Step 2: Install Groovy Extensions

Open VS Code and install these extensions from the Extensions marketplace (Ctrl+Shift+X):

1. Groovy Language Support (by Marlon Franca) – syntax highlighting and basic language support
2. Code Runner (by Jun Han) – run Groovy scripts with a single click

Install Extensions via CLI

code --install-extension marlon407.groovy-lang
code --install-extension formulahendry.code-runner

Step 3: Configure Code Runner for Groovy

Open VS Code settings (Ctrl+,) and search for “code-runner.executorMap”. Add this to your settings.json:

VS Code settings.json

{
    "code-runner.executorMap": {
        "groovy": "groovy"
    },
    "code-runner.runInTerminal": true,
    "code-runner.saveFileBeforeRun": true
}

Step 4: Create and Run a Groovy Script

1. Create a new file: hello.groovy
2. Add your code
3. Press Ctrl+Alt+N to run (Code Runner shortcut)

VS Code – Test Script

println "Hello from VS Code!"
def languages = ["Groovy", "Java", "Kotlin"]
languages.each { lang ->
    println "  - ${lang}"
}

Output

Hello from VS Code!
  - Groovy
  - Java
  - Kotlin

VS Code Groovy Limitations

Be aware of these limitations compared to IntelliJ:

• No built-in Groovy debugger (you need additional configuration)
• Code completion is basic – no deep type inference
• No Grails project support
• Refactoring support is limited

VS Code works great for Groovy scripting and smaller projects. For full Grails applications, IntelliJ is a better choice.

Setting Up Groovy in Eclipse

Eclipse has been around forever, and its Groovy support through the Groovy Development Tools (GDT) plugin is mature and reliable. If Eclipse is already your IDE, you don’t need to switch – Groovy works well here.

Step 1: Install Eclipse

Download Eclipse IDE for Java Developers from eclipse.org.

Step 2: Install Groovy Development Tools

1. Go to Help → Eclipse Marketplace
2. Search for “Groovy Development Tools”
3. Click Install and follow the prompts
4. Restart Eclipse when prompted

Step 3: Create a Groovy Project

1. Go to File → New → Project
2. Select Groovy → Groovy Project
3. Name your project and click Finish

Step 4: Create and Run a Groovy Script

1. Right-click src → New → Groovy Class
2. Name it Hello
3. Add your code and run with Ctrl+F11

Eclipse – Test Script

println "Hello from Eclipse!"
println "Running Groovy ${GroovySystem.version}"

Output

Hello from Eclipse!
Running Groovy 5.0.6

Groovy Console – The Built-in Alternative

Here’s something a lot of developers don’t realize – Groovy ships with its own GUI console. No IDE needed. It’s perfect for quick experiments and learning.

Launch Groovy Console

groovyConsole

This opens a Swing-based editor with a split view – code on top, output on the bottom. Type your code, press Ctrl+R to run, and see the result instantly.

Groovy Console – Quick Test

// Try this in Groovy Console
def fruits = ["apple", "banana", "cherry"]
fruits.each { fruit ->
    println "I like ${fruit}!"
}

println "\nTotal fruits: ${fruits.size()}"

Output

I like apple!
I like banana!
I like cherry!

Total fruits: 3

The Groovy Console also supports Ctrl+W to clear output, Ctrl+S to save scripts, and even script history. It’s a hidden gem for quick prototyping.

Pro Tip: The Groovy Console is also available inside IntelliJ IDEA at Tools → Groovy Console. It uses your project’s classpath, so you can test code with your project’s dependencies.

Which IDE Should You Pick?

Here’s my honest recommendation based on your use case:

If you’re just getting started and don’t have a preference, go with IntelliJ IDEA Community Edition. It’s free, has the best Groovy support, and you’ll never outgrow it.

Running Your First Project

Let’s verify your Groovy IDE setup is working correctly with a slightly more involved script. Create this file in whichever IDE you chose:

Verify IDE Setup

// verify-setup.groovy - Test your Groovy IDE setup
println "=== Groovy IDE Setup Verification ==="
println ""

// 1. Basic output
println "1. println works: OK"

// 2. Variables and GString
def name = "TechnoScripts"
println "2. GString interpolation: Hello, ${name}!"

// 3. List operations
def numbers = [1, 2, 3, 4, 5]
println "3. List sum: ${numbers.sum()}"

// 4. Closure
def square = { n -> n * n }
println "4. Closure (5 squared): ${square(5)}"

// 5. Map
def config = [language: "Groovy", version: GroovySystem.version]
println "5. Map: ${config}"

// 6. String manipulation
println "6. Uppercase: ${'hello groovy'.toUpperCase()}"

// 7. Range
def range = (1..5)
println "7. Range collect: ${range.collect { it * 2 }}"

println ""
println "=== All checks passed! Your IDE is ready. ==="

Output

=== Groovy IDE Setup Verification ===

1. println works: OK
2. GString interpolation: Hello, TechnoScripts!
3. List sum: 15
4. Closure (5 squared): 25
5. Map: [language:Groovy, version:5.0.6]
6. Uppercase: HELLO GROOVY
7. Range collect: [2, 4, 6, 8, 10]

=== All checks passed! Your IDE is ready. ===

If all 7 checks pass, your IDE is properly configured and you’re ready to start learning Groovy. Next up, you might want to understand the def keyword and dynamic typing.

Common Groovy IDE Setup Issues and Fixes

Issue 1: “Groovy SDK Not Found”

Problem: IntelliJ can’t find your Groovy installation.

Fix: Go to File → Project Structure → Libraries → Add → Groovy SDK and point to your Groovy home directory. On SDKMAN, that’s typically ~/.sdkman/candidates/groovy/current. On Windows, check C:\groovy-5.0.6 (the version at the time of writing) or wherever you extracted it.

Issue 2: “Cannot Resolve Symbol” Warnings

Problem: IDE shows red underlines on valid Groovy code like def or GDK methods.

Fix: Make sure the Groovy library is added to your project module. In IntelliJ: File → Project Structure → Modules → Dependencies → Add → Library → Groovy.

Issue 3: VS Code Doesn’t Recognize .groovy Files

Problem: No syntax highlighting for .groovy files.

Fix: Install the “Groovy Language Support” extension. If it’s already installed, check the bottom-right corner of VS Code – click the language mode and select “Groovy” manually.

Issue 4: Wrong Java Version

Problem: Groovy 5.0.6 fails with “Unsupported class file major version” errors.

Fix: Groovy 5.0.6 requires Java 17+. Check your IDE’s project SDK setting and make sure it points to Java 17 or higher. In IntelliJ: File → Project Structure → Project → SDK.

Issue 5: Slow Groovy Compilation in Eclipse

Problem: Eclipse is slow when compiling Groovy files.

Fix: In Eclipse preferences, go to Groovy → Compiler and make sure “Enable script folder support” is checked only for folders containing scripts. Disable it for regular source folders to speed up compilation.

Conclusion

A working Groovy IDE setup doesn’t have to be complicated. IntelliJ gives you the most complete experience, VS Code keeps things lightweight, and Eclipse works if it’s already your home. And for quick experiments, the built-in Groovy Console is hard to beat.

The important thing is to pick one and start coding. You can always switch later – your Groovy skills transfer across any editor.

Now that your environment is ready, it’s time to learn the language itself. Start with the def keyword to understand how Groovy handles types, or jump into closures if you want to see what makes Groovy truly special.

Summary

• IntelliJ IDEA Community (free) has the best Groovy support out of any IDE
• VS Code with Code Runner extension works well for scripts and learning
• Eclipse needs the Groovy Development Tools plugin from the Marketplace
• Groovy Console (groovyConsole) ships with Groovy – zero extra setup
• Always verify with Java 17+ and Groovy 5.0.6 versions before starting

If you also work with build tools, CI/CD pipelines, or cloud CLIs, check out Command Playground to practice 105+ CLI tools directly in your browser — no install needed.

Up next: Groovy Def Keyword – Dynamic Typing Explained

Frequently Asked Questions

Interview Questions on Groovy IDE Setup

“Scenario questions, not trivia: this is the form this topic takes in a real interview.”

Q: A new teammate opens your Gradle project in IntelliJ and every build.gradle file is a sea of red “cannot resolve” underlines, yet the build runs fine from the terminal. What do you check first?

Whether the project was actually imported as a Gradle project. Those build files are Groovy, but their classpath comes from Gradle’s tooling API, not the project SDK, so until IntelliJ finishes a Gradle sync the DSL methods look unresolved. The fix is usually reimporting from the Gradle tool window, checking the Gradle JVM setting points at Java 17 or newer, and letting indexing finish. The gotcha: red underlines in the IDE say nothing about whether the build works, because the terminal build never consults IntelliJ’s model.

Q: A script runs perfectly inside your IDE but on the Jenkins agent it dies with “unable to resolve class”. Why does the same file behave differently?

Classpath. When the IDE runs the script it quietly adds every module dependency to the classpath, so imports resolve. On the agent, plain groovy myscript.groovy only sees the Groovy distribution jars plus whatever you pass with -cp. So either ship the dependency on the classpath, use @Grab to fetch it at runtime, or run the script through the same Gradle build the agent uses. Also worth checking that the agent’s Groovy version matches; a script tested on Groovy 5 can trip on an older runtime the box has baked in.

Q: Your mixed Java and Groovy project compiles in the IDE, but a plain javac-based build fails wherever Java classes call Groovy classes. What is going on?

That is a joint compilation problem. javac has no idea what a .groovy file is, so any Java class referencing a Groovy class fails to resolve. The Groovy compiler solves this by generating Java stubs for Groovy classes first, letting javac compile against the stubs, then producing the real bytecode. IDEs and Gradle’s groovy plugin do this for you, which is why it “just works” there. The practical fix is to route compilation through Gradle and, in the classic layout, keep cross-referencing sources in src/main/groovy so they compile together.

Q: Running your project from the terminal throws “Unsupported class file major version 61”, but the IDE runs it fine. How do you diagnose that?

Major version 61 is Java 17 bytecode, so something on the terminal path is running an older JVM than the IDE uses. The IDE has its own project SDK setting, while the terminal honors JAVA_HOME and PATH, and the two drift apart all the time. I would run java -version in that terminal, expect to see 8 or 11, and repoint JAVA_HOME to a 17+ JDK. Worth adding that Groovy 5 requires Java 17 as its floor, so any environment still on Java 11 cannot run it at all.

Q: IntelliJ happily shows inferred types on def variables, yet a typo in a method name only blows up at runtime. Why, and how would you tighten that?

Because Groovy is dynamic by default. The IDE’s inference is a best-effort hint; the compiler still defers method resolution to runtime, so a misspelled method becomes a MissingMethodException when the line executes, not a compile error. To tighten it, annotate the class or method with @TypeChecked to make the compiler verify calls statically, or @CompileStatic to also compile with static dispatch. Once those annotations are on, the IDE flags the typo immediately, and you get the error at build time instead of in production.

Related Posts

Previous in Series: Groovy Hello World – Your First Groovy Program

Next in Series: Groovy Def Keyword – Dynamic Typing Explained

Related Topics You Might Like:

• Groovy Closures – The Complete Guide
• Groovy String Tutorial – The Complete Guide
• Groovy -e Command Line Option – Run Scripts Instantly

This post is part of the Groovy & Grails Cookbook series on TechnoScripts.com