# intellij-solidity gives IntelliJ a Solidity language plugin

> The intellij-solidity plugin adds Solidity support to IntelliJ based IDEs: syntax highlighting, completion, navigation, formatting, file templates and a Forge test runner that puts run icons in the gutter of test files. It is written in Kotlin, built with Gradle, and distributed through the JetBrains Marketplace under plugin id 9475.

**intellij-solidity/intellij-solidity** — Solidity plugin for IntelliJ

- Repository: https://github.com/intellij-solidity/intellij-solidity
- Website: https://intellij-solidity.dev
- Stars: 1,100 · Forks: 105
- Language: Kotlin
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/intellij-solidity-intellij-solidity

## An editor that understands the contract, not just the syntax

intellij-solidity is a Solidity plugin for IntelliJ, and the plugin page is linked from the readme with the plugin logo, so the distribution route is the JetBrains Marketplace, plugin id 9475. The project site is intellij-solidity.dev.

The primary language of the repository is Kotlin, and the plugin is built with the IntelliJ plugin toolchain, with a Gradle wrapper and Kotlin DSL build files at the root.

The audience is a Solidity developer already inside an IntelliJ based IDE. That is a narrower audience than it sounds, because the plugin list in the readme is a list of IDE features rather than a list of language features. Syntax highlighting is the entry level. Code completion is the one developers feel first. File templates, goto declaration and find usages are navigation and scaffolding. Code formatting is the one that changes your day to day work, because a formatter that agrees with the project style saves a review comment every time.

The point of a language plugin is that the editor understands the semantics of the language rather than just colouring the tokens, and that is exactly what this feature list describes. A find usages that understands a Solidity inheritance chain or an interface is a different tool from a text search, and a completion that knows the types of a contract is a different tool from a keyword completer.

The repository is not archived and the last push was on 2026-10-03, with the release history showing 2.4.9 on 2025-09-09, 2.4.10 on 2025-12-13 and 2.4.11 on 2026-02-08. The licence is MIT, in the LICENSE file at the root.

## The Forge test runner is the feature that ties the plugin to a toolchain

One entry in the feature list is different from the others, and it is the one worth understanding first:

Forge test runner with gutter icons for running tests in *.t.sol files.

Everything else in the list is a generic IDE capability that a language plugin provides. This one is specific to Foundry, and specific to a file naming convention, the.t.sol suffix.

The mechanism is the familiar IDE pattern. A file whose name matches the test pattern gets a gutter icon next to each test function, and clicking that icon runs the test. The advantage over a terminal is not that it is faster, it is that the run happens in the editor at the line you are looking at, so a failing test takes you straight to the failure.

The convention that makes it work is worth understanding, because it is what the plugin keys off. The plugin keys off the.t.sol suffix in the file name. That is a small piece of convention shared between the build tool and the editor, and it is the kind of integration that is either clean or impossible, and this one is clean.

The cost is that the plugin is now coupled to a specific toolchain and a specific naming convention. If your Foundry project names its test directory differently, the standard Foundry convention of a test directory with.t.sol files, the gutter icons will not appear. That is a small thing and it is a real thing, and it is the clearest example in this project of a design decision that trades generality for fit.

## Building the plugin and running it from source

The build and run commands are the whole development story, and they are the standard Gradle wrapper invocations:

```bash
./gradlew buildPlugin
```

buildPlugin produces the plugin artefact, which is what you then install into an IDE. And to run the plugin in a development IDE:

```bash
./gradlew runIdea
```

runIdea launches an IntelliJ instance with the plugin loaded, which is how a plugin developer works, since the thing being developed is a set of extensions to an IDE and you need the IDE to see them.

The repository layout is what you would expect for a JetBrains plugin. There is a src directory for the plugin code, a gradle directory and the gradle wrapper with gradlew and gradlew.bat for Unix and Windows, build.gradle.kts and settings.gradle.kts as the Gradle Kotlin DSL build definition, and gradle.properties. There is an .idea directory with the project configuration, and an .editorconfig for formatting. There is a logo directory, and the .circleci directory with the continuous integration configuration, plus a .travis.yml, which is a leftover from an earlier CI era.

The development documentation lives in DEVELOPING.md at the root, and there is an AGENTS.md as well, which is the convention for instructions aimed at coding agents, and a .junie directory, which serves a similar purpose for another assistant tool. Their presence tells you the project expects contributions from people who are not fluent in the IntelliJ plugin SDK.

The contribution guidance in the readme is unusually welcoming for a plugin project. It says that if you are only starting your way as an IntelliJ plugin developer, feel free to contact them and they will help with the IDE setup and guide you through the code so that you can make a first contribution and fix that annoying bug that drives you nuts, and then, if you are keen, dive deeper into lexers, parsers, types, refactorings and code analysers.

That list is the real map of the codebase. A language plugin is mostly a lexer, a parser, a type system, some refactorings and an analyser, and the readme is telling you which five areas to expect.

## The feature list stops at the editor

The most important thing to know about this plugin is where its scope ends, and the feature list is short enough to read as a boundary.

There is syntax highlighting, code completion, file templates, goto declaration, find usages, code formatting and the Forge test runner. Every one of those is an editor capability. There is no entry for static analysis, no entry for a compiler inside the editor, no entry for security auditing, no entry for gas analysis, no entry for deployment or for reading chain state, and no entry for anything that talks to a node.

So the plugin makes your editor understand Solidity. It does not make your editor verify that your contract compiles, and it does not tell you anything about whether the code is safe.

That distinction matters more for Solidity than it does for most languages, because the failure modes are expensive. A tool that reformats your code and helps you navigate it is worth having. A tool that gives you a green tick on a contract with a reentrancy bug is worth something else entirely, and this is not that tool.

The other limitation is the plugin platform itself. The plugin is for IntelliJ, which means IntelliJ IDEA and the other IDEs on the same platform, and it does not help a developer working in Visual Studio Code or someone using a browser based editor such as Remix. The feature set is comparable to what a competing plugin for those editors might offer, but the tooling around it, the Foundry integration and the CI setup, will not be.

The honest summary is that this is a well scoped language plugin that does the language plugin things well, and if your Solidity workflow lives inside an IntelliJ based IDE it is a reasonable default, while if it lives anywhere else the decision is made for you.

## How the plugin is distributed and updated

The distribution route is the JetBrains Marketplace, and the readme links the plugin page with the plugin id 9475 in the badge. That is the normal channel for an IntelliJ plugin, and it means the update path is the one every other plugin in your IDE uses, which is to say it is invisible until it matters.

Two things are worth noting about that route. First, the plugin is community maintained rather than published by JetBrains, so it follows the marketplace's review and compatibility process rather than a first party one, and a plugin update that breaks with a new IDE release is a possibility you accept when you install a third party plugin into your editor. Second, the version numbers in the release history, 2.4.9, 2.4.10 and 2.4.11, are the plugin's own version, and they are what the marketplace serves, not a tag in the repository.

For anyone who wants to run a modified version, the build path produces a plugin artefact that can be installed from disk, which is the standard way to test a change before it is published. The development documentation covers the rest of the workflow.

The support model is stated simply in the readme. You can support the development by sponsoring the plugin on GitHub, or even by simply clicking the star on GitHub and rating it on the plugin page. Both are cheap ways to support the plugin.

The issue reporting guidance is also specific: please attach the screenshot for every issue if possible, because it will make the issue much clearer and easier to understand. For a plugin whose bugs are often visual, a wrong indentation in a screenshot, a mis-highlighted token, that request is reasonable, and it is a reminder that what you are adopting is a piece of UI tooling as much as a language implementation.

## Conclusion

intellij-solidity is worth adopting if you write Solidity in an IntelliJ based IDE, because the navigation and completion features are the part of the toolchain that the compiler and the chain cannot give you, and the Forge test runner with gutter icons is the feature that decides whether the plugin earns its place in a Foundry workflow. It is the wrong choice if you want static analysis, a security auditor or a compiler inside your editor, because the documented feature list stops at IDE level navigation and formatting. Before you install it, decide whether you want the plugin from the JetBrains Marketplace or from a local build, and check the DEVELOPING.md document if you intend to contribute, and note that the current version is 2.4.11 from 2026-02-08 while the repository was pushed to on 2026-10-03.

## FAQ

### What does the intellij-solidity plugin provide?

Syntax highlighting, code completion, file templates, goto declaration, find usages, code formatting, and a Forge test runner that puts gutter icons for running tests in *.t.sol files.

### How do I build the intellij-solidity plugin from source?

The repository ships a Gradle wrapper. Run ./gradlew buildPlugin to produce the plugin artefact and ./gradlew runIdea to launch a development IDE with the plugin loaded. The development documentation is in DEVELOPING.md at the repository root.

### How do I install the Solidity plugin for IntelliJ?

It is published on the JetBrains Marketplace under plugin id 9475, and the readme links that plugin page. The repository does not document a separate manual installation procedure for end users.

### What is the Forge test runner in intellij-solidity?

It adds gutter icons for running tests in files matching the *.t.sol pattern, so a test can be run from the editor at the line it is defined on. The feature is tied to the Foundry naming convention rather than to a general test discovery mechanism.

### Is the intellij-solidity plugin MIT licensed and still maintained?

The repository carries an MIT licence in its LICENSE file, it is not archived, and the last push was on 2026-10-03. The release history shows version 2.4.11 published on 2026-02-08, after 2.4.10 on 2025-12-13 and 2.4.9 on 2025-09-09.

## Sources

- [intellij-solidity/intellij-solidity on GitHub](https://github.com/intellij-solidity/intellij-solidity)
- [License: MIT](https://github.com/intellij-solidity/intellij-solidity/blob/master/LICENSE)
- [Project website](https://intellij-solidity.dev)
- [README](https://github.com/intellij-solidity/intellij-solidity/blob/master/README.md)
- [Releases](https://github.com/intellij-solidity/intellij-solidity/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/intellij-solidity-intellij-solidity