repowiserepowise

App

l0ng-ai / openidea

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

★ 9,298stars on GitHubTypeScriptApache-2.0

This connects Repowise to l0ng-ai/openidea's code. It does not install openidea.

Repowise maps public repos from their source. Not affiliated with l0ng-ai. What is Repowise?

github.com/l0ng-ai/openideaIndexed at 108da53

What is openidea?

OpenIDEA is a native desktop IDE with a Rust core, built for developers who want the IntelliJ IDEA way of working. It provides an editor, code insight, a debugger, Git, a terminal, and database and HTTP clients for 60+ languages. The frontend is written in TypeScript, the backend packages are written in Rust, and it builds for macOS, Windows and Linux. Its code health is 7.7 out of 10 (Good), ranked #93 of 4,000+ indexed repos. The last commit to openidea was on Nov 11, 2026, and 62 people have contributed.

As of commit 108da53, indexed Nov 11, 2026. What it is comes from a model reading the README; the rest is measured from the source and git history, not from the maintainer.

For agentsopenidea.md

Repo facts: type, license, health, rank, contributors
openidea facts
TypeApp
LicenseApache-2.0
Code health7.7 / 10 (Good)
Health rank#93 of 4,000+ indexed repos
Last commitNov 11, 2026
Contributors62
Bus factor3
Size3,417 files, 666,277 lines

Explore openidea

Ask about this code in your agent

This connects Repowise to openidea's code. It does not install openidea.

Useful if you want to change or fork openidea: your agent can ask how it is put together and get answers that cite its files.

Ask about openidea

Answers come from openidea's README and source, with the files they cite. Two free answers a day without an account.

Featured answer

openidea is a native desktop IDE with a Rust core, built for developers who want the IntelliJ IDEA way of working, with an editor, code insight, a debugger, Git, a terminal, and database and HTTP clients for 60+ languages. The frontend in src is written in TypeScript and holds typed calls that reach the native backend through Tauri commands in src-tauri. Those commands call into backend packages in the crates directory, each with its own entry point, such as crates/ide-analysis/src/lib.rs, crates/ide-build/src/lib.rs and crates/ide-agent/src/lib.rs. Of the 3417 files, the Application layer holds 1638, Docs & Tooling holds 386, and Service holds 119, while the scripts directory supports development and release work and the perf directory measures startup and keystroke response. To start reading, begin with the src frontend and then the crates entry points listed above.

Files per layer in openidea9 layers.

Basis: Inferred · knowledge graph· as of 108da53

Want this for your own codebase? Map your repo free

About this page

Get a page like this for your own codebase

Repowise built this map of l0ng-ai/openidea from its source and git history. It parses every symbol, draws the dependency graph, scores each file's health from complexity, duplication, coverage and churn, finds hotspots and owners in the history, and writes documentation for every module. Your coding agent reads the same index over MCP, so its answers cite real files.

Free for 2 public repos, with a page like this one. No card. See how Repowise works

Prefer local? pip install repowise && repowise init indexes your own checkout, no account needed. Star Repowise on GitHub

l0ng-ai/openidea FAQ

What is OpenIDEA?

OpenIDEA is a native desktop IDE with a Rust core for developers who want the IntelliJ IDEA way of working. It covers editing, debugging, Git, terminal, database and HTTP clients across 60+ languages.

How does OpenIDEA work?

OpenIDEA runs a TypeScript frontend in src that calls typed backend functions through Tauri commands in src-tauri. Those commands call the packages in crates, which take a request value and return a typed result or an error.

What language is OpenIDEA written in?

OpenIDEA is written in TypeScript and Rust. The frontend in src uses TypeScript, and the backend packages in crates are written in Rust.

How is the OpenIDEA code organized?

OpenIDEA keeps its frontend in src and its backend feature packages in crates. The desktop shell code lives in src-tauri, helper scripts are in scripts, and performance measurements are in perf.

Who is OpenIDEA for?

OpenIDEA is for developers who want the IntelliJ IDEA way of working on macOS, Windows and Linux. It is meant for editing, debugging and Git across 60+ languages, with the keymap and tool windows they already know.

What license does OpenIDEA use?

OpenIDEA uses the Apache-2.0 license.

Code health

7.6out of 10Good

Hotspots average 5.9, the place fixes pay off most.

On the leaderboards:#36 of 70 TypeScript repos

Key features of openidea

  • Provides an editor, code insight, debugger, Git, terminal, database and HTTP clients.
  • Keeps the IntelliJ IDEA keymap, tool windows and search-everything habits.
  • Supports 60+ languages.
  • Builds for macOS, Windows and Linux.
  • Plugins can add actions, completion, quick fixes, tool windows, custom editors, themes, file icons and languages, and run as sandboxed WebAssembly components.

How l0ng-ai/openidea works

The frontend in src starts the desktop IDE and holds the typed calls that reach the native backend. The Tauri commands in src-tauri call into the backend packages in crates, which supply features behind the panels such as debugging, file editing and coverage reports. A caller passes a request value to one of these packages and gets back a typed result or an error. The entry points crates/ide-analysis/src/lib.rs, crates/ide-build/src/lib.rs and crates/ide-agent/src/lib.rs are the entry points of separate backend packages. The scripts directory holds helper scripts for development and release work, such as theme token generation and release version updates. The perf directory measures how quickly the app starts, opens its tool windows and responds to keystrokes, and fails a run when a measurement is over budget.

The codebase has 3,417 files and 47,122 symbols in 12 modules, led by TypeScript, Rust and Java. Code health is 7.6 out of 10, rated good.