Opening

A brand-new project that rocketed to 7.2k stars in 30 days, with a README that benchmarks itself directly against its elders: open freqtrade (a Python project with roughly 770 files) in OpenIDEA and it's ready in 1.1 seconds using 169 MB, versus IntelliJ IDEA 2026.2.3 at 13.2 seconds and 2011 MB. I'm Muyan, and today we also have Mika, an Android agent you'd actually dare install on your daily driver, plus auto-ontology, NVIDIA's official open source release that pulled 289 points on Hacker News. I'll explain shortly how it teaches a text-to-SQL agent to say "I can't answer that."

Today's Open Source Picks

1. OpenIDEA: Keep IntelliJ's muscle memory, drop the JVM startup and memory bill

• What it is: Every Java/Kotlin developer lives with the same contradiction: IntelliJ's shortcuts and tool windows are already wired into your fingers, but waiting for indexing every day and watching gigabytes of RAM disappear gets old fast. OpenIDEA ports IDEA's entire interaction model over (keymap, tool windows, search-everywhere) but wraps it in a lightweight native shell. Built for people who don't want to relearn shortcuts and are done with startup times.
• Recent buzz: 7,251 GitHub stars, a project that appeared within the last 30 days, Apache-2.0 licensed, primarily TypeScript. HN has an entire thread arguing over whether it counts as "rebuilt in Rust."
• Standout features: A single app containing the editor, code insight, debugger, Git, terminal, database client, and HTTP client, supporting 60+ languages with builds for all three platforms. The README includes the benchmark numbers above and, refreshingly honestly, notes that "IDEA performs deeper Python analysis, so 'ready' doesn't mean both are doing the same work." It also ships perf/compare so you can rerun everything on your own machine.
• Getting started: The fastest path is grabbing the installer for your platform from GitHub Releases: macOS, Windows, and Linux are all covered. To build it yourself, run pnpm install && pnpm tauri dev; you'll need Rust 1.96, Node 22, and the Tauri prerequisites.
• Versus the alternatives: Zed and Lapce, the other Rust-family editors, render their entire UI in Rust. OpenIDEA goes the Tauri route: a Rust core with a WebView/TypeScript frontend, which is exactly why some HN commenters feel "rebuilt in Rust" oversells it. I think that criticism is fair, but the real selling point was never pure Rust anyway, it's "IDEA's feel in a lightweight shell." The README also states plainly that the project is unaffiliated with JetBrains, so don't treat it as a feature-equivalent IDEA replacement.
• Who it's for: Anyone who can't live without IntelliJ shortcuts but whose main machine is running out of memory.
• Link: https://github.com/l0ng-ai/openidea

2. Mika: A computer-use agent running inside your phone, with no official server

• What it is: A mobile computer-use agent. It opens apps, taps, types, and scrolls on a hidden background virtual display while you keep using your phone normally; pop open a small window anytime to watch progress live. Built for people who want to automate phone tasks but balk at handing their screen contents to some vendor's backend.
• Recent buzz: 7,301 GitHub stars, also a project from the last 30 days, Apache-2.0, primarily Kotlin, fully open source.
• Standout features: It works by "looking at the screen and finding buttons" via accessibility, so apps don't need to expose an API and there are no per-app integrations to build; any app or website works. A built-in browser lets you issue commands against the current page, and it stops the moment you touch the screen. It remembers preferences you've mentioned and distills completed tasks into skills, so repeat runs get faster and more reliable.
• Getting started: Download the APK from Releases (Android 11+), go to Settings › Model to pick a provider and enter your API key, then run the "Set up phone control" wizard once to pair wireless debugging. If you only want chat, web, and file features, you can skip step three. The README even provides a command that lets an AI agent on your computer set the whole thing up for you.
• Versus the alternatives: Unlike mobile agent services that ship your screen to a vendor cloud, Mika has no backend of its own; the agent loop runs locally on the phone. It's also not limited to first-party apps the way built-in vendor assistants are. But let's be clear about the catch: no Mika server doesn't mean fully offline, since the model still comes from your own API key or a ChatGPT/xAI/OpenRouter account. And letting it tap your screen requires enabling accessibility and pairing wireless debugging, which are substantial permissions. Think it through before installing.
• Who it's for: Self-hosting Android users who worry about data leaving their device but still want to offload repetitive phone tasks.
• Link: https://github.com/wangzan101/Mika

3. NVIDIA auto-ontology: Getting data agents to admit "I can't answer that"

• What it is: Anyone who's built text-to-SQL or data agents has hit the same wall: the agent answers fast and confidently, and the answer is wrong. auto-ontology automatically compiles an ontology layer from database metadata, mapping business terms to columns, measures to vetted SQL, and relationships between tables. The agent queries this semantic graph instead of guessing. Built for teams actually connecting agents to production databases inside an enterprise.
• Recent buzz: 289 points and 139 comments on Hacker News, 8,260 GitHub stars, officially open sourced by NVIDIA, Apache-2.0, primarily Python.
• Standout features: An answerability check that first determines whether a question can be answered at all, and if not, has the agent ask a follow-up instead of confidently making things up. Every answer comes with the SQL and the agent's steps. The same context can be fed to any agent harness via MCP, agent skills, or the REST API, while definitions can be manually reviewed and certified in the Web UI or via API. There's also a companion auto-ontology-eval repo that runs same-model, two-prompt experiments comparing "schema stuffed into the prompt" against "going through the ontology" on BIRD, BEAVER, FDABench-Lite, and Wide World Importers, scored with deterministic verifiers. This benchmark suite is the vendor's own repo, so treat it as a reproducible methodology rather than third-party validation.
• Getting started: The repo includes a Dockerfile, docker-compose.yml, and a helm chart. Clone .env.example, run docker compose to spin up a service alongside your database, then point your agent at the MCP endpoint and you're done.
• Versus the alternatives: The most common homegrown approach is pasting the entire schema into the context window, where tokens grow linearly with tables and columns, and joins and measures get improvised by the agent every single time. auto-ontology instead gives the agent tools to query the ontology and pull only the terms and tables relevant to the question at hand. It can also import your existing semantic model; it's positioned to complement semantic layers you already have like dbt and Cube, not replace them.
• Who it's for: Data engineering teams sitting on a pile of tables and suffering through agent-generated garbage SQL.
• Link: https://github.com/NVIDIA/auto-ontology

Closing

Today's three picks share an obvious theme: replacing "the model just guesses" with "there's structure to query." OpenIDEA strips out the IDE's weight while preserving its interaction habits, Mika pulls the agent back onto your own device, and auto-ontology lays down a queryable semantic map for agents. If you forced me to pick one to install tonight, it's OpenIDEA: downloading an installer is the lowest-cost commitment, and since the README ships perf/compare, you can verify that 1.1 second figure on your own project. One note: the release dates for these three projects weren't confirmed in the material I had, and the star counts are snapshots from when I did the research, so check the repos for current numbers. See you tomorrow.