Language support
A dedicated, current view of which languages and project shapes cix handles, broken into three honest tiers. If your project's primary language isn't on the Full list, read the rest of the page before deciding whether cix is worth your time.
This page is the source of truth for language coverage. The other pages reference it; the support tier you find here is the one to trust.
How the tiers work
Full support. A parser exists. Symbol-level features (find existing code, look up a definition, file outline) work. The schema view works where the project uses a supported migration format. Impact analysis and convention enforcement work end-to-end. Standard project shapes in this language score 13–15 on our benchmark rubric.
Partial coverage. A parser exists and the basics work, but common patterns in this language (or its dominant frameworks) lose coverage in specific areas. The system tells you when this happens — you'll see partial-coverage flags rather than fabricated answers.
Unsupported. No parser today. File-level operations still work — listing files, searching by path, checking convention rules. Symbol-level features, schema, routes, and impact analysis return empty or unsupported rather than guesses.
Full support
| Language | Common stacks tested | Notes |
|---|---|---|
| Python | Flask, FastAPI, Django, Airflow, NetBox | The strongest-coverage language. Schema view via Alembic, SQLAlchemy, and Django migrations. |
| JavaScript | Express, Node, vanilla | Strong on standard MVC and REST shapes. |
| TypeScript | Vue, React, Next.js, Express, Nest | Strong on conventional projects; see Partial section for monorepo caveats. |
| Java | Spring Boot | Annotation-driven routing, JPA models, and Spring conventions all index cleanly. |
| C# | ASP.NET Core | Controller routing, EF Core models, conventional folder structure handled. |
| PHP | Laravel, generic | Eloquent migrations, Laravel route registration, controller-resource patterns. |
| Ruby | Rails-shaped projects | Active Record, Rails-style controllers, conventional layouts. |
| Go | Standard net/http, common router libs | See Partial section for the dynamic-handler caveat below. |
These are the languages where the 25-repo benchmark scored projects 13/15 or higher when the project shape was conventional.
Partial coverage
Even within full-support languages, specific patterns lose coverage. These are honest about the gap rather than blockers — most projects can live with them once they're known.
Dynamic route/handler registration. Projects that register HTTP routes programmatically at runtime (rather than declaratively) are partially visible to the index. Affects Go projects using runtime module managers (Loki, rclone-style architectures), some Node projects using plugin-based routing (Strapi, parts of Saleor), and Python projects with custom dispatch layers. Symbol search and schema work fine; the route list is partial. Benchmark scores in this band tend to land 9–11/15.
Custom migration runners. The schema view parses Laravel, Django, Alembic/SQLAlchemy, Prisma, and raw SQL. A team that has built its own migration framework (or uses a less-common ORM) will see partial or empty schema coverage. The system reports the parse status explicitly.
Same-name symbols across packages. When two unrelated types share a name across packages, impact analysis sometimes resolves to one when the user meant the other. The output flags this as a confidence issue. Affects every language but shows up most often in Go and TypeScript monorepos.
Test fixtures bleeding into route lists. Some projects register test-only routes through normal mechanisms; cix has no native "this is test-only" classifier beyond directory heuristics. On large projects, a few test routes can leak into the production route list.
Monorepo-scale TypeScript. TypeScript projects sometimes hit a combination of the patterns above (dynamic plugin loading, multi-package test fixtures). Per-package work is unaffected; cross-package queries are where the partial flags show up.
Unsupported
These have no parser today. File listing, path-shaped search, and convention enforcement still work; symbol-level features and the schema view return empty.
| Language | Notes |
|---|---|
| Lua | The most-discussed gap. Affects Kong, OpenResty, and Neovim-plugin codebases. Benchmark scores on Lua-heavy projects sit in the 1–4/15 range. Listed on the roadmap. |
| Erlang / Elixir | No parser. Phoenix projects work only at file level. |
| Crystal | No parser. |
| Zig | No parser. |
| Haskell | No parser. |
| Scala | No parser. |
| Lisp / Scheme dialects | No parser. Includes Clojure. |
If your codebase is primarily in one of these, defer adoption until parser support lands or your project mix shifts. The system is explicit about the gap rather than fabricating around it — see Limitations for the broader honesty commitment.
Migration formats (separate from language)
The schema view depends on parsing migration files, which is a layer above language support.
Supported migration formats:
- Laravel migrations (PHP, Eloquent schema builder)
- Django migrations (Python, auto-generated and hand-written)
- Alembic migrations (Python, SQLAlchemy and FastAPI ecosystems)
- Prisma schema files
- Raw SQL migrations (
CREATE TABLE,ALTER TABLE)
Partial: ORM-only fields not declared in any migration, mutations that change rather than create columns, database-specific types (Postgres tsvector, JSONB schemas embedded in text columns).
Unsupported: Custom migration runners, hand-rolled ORMs without one of the supported migration patterns. The schema view returns empty with an explicit note.
How to read this page
If your primary language is in Full support and your project shape is conventional, cix delivers high value at low setup cost.
If your project hits one of the Partial coverage patterns, cix still helps but you should expect some queries to return partial results. The 25-repo benchmark places these projects in the 9–11/15 band — useful, not comprehensive.
If your primary language is Unsupported, defer. The system is honest about it; the value to you is small until the parser lands. Track the roadmap if you want a heads-up when this changes.
Related
- 25-repo benchmark — measured per-project performance, broken down by language and shape.
- Limitations — the broader honest-behavior story.
- Roadmap — what's on deck for new parsers and pattern coverage.
- For evaluators — how to test cix on your own codebase before adopting.