Local code intelligence. Ask questions about any codebase, get accurate answers.
Overview · Install · Usage · Docs · Known Issues
Important
🚧 Beta Release Core features are stable. Breaking changes are not expected for the next few releases. First stable release scheduled for late June / early July 2026. Please report issues — documentation contributions especially welcome.
Eulix builds a structured knowledge base from your source code — symbols, call graphs, control flow, and semantic embeddings — then uses a multi-layer retrieval pipeline to answer questions about it with sub-second latency, grounded in actual code structure rather than guesses.
Your code never leaves your machine. All parsing, indexing, and reasoning run locally. Cloud LLM providers are supported as an opt-in.
| Component | Benchmark |
|---|---|
| Parser (Rust, 12 threads) | 26M LOC/min · with approximate call graphs |
| Embedder (Python, AMD Navi 22) | 1.5GB JSON · 768-dim model · ~35 min |
| Retrieval (Go, 2GB codebase) | ~300ms end-to-end including re-ranking |
| PRISM call graph | ~6s · ~35-75% approximation accuracy depending upon language |
eulix analyzeEulix runs three focused pipelines over your source code:
- Symbol index — every function, class, variable, and its location
- PRISM call graphs — polyglot call graph approximation via inverted symbol map. Fast, documented tradeoffs — see known issues
- Semantic embeddings — per-symbol vectors via your choice of local or remote model
eulix chatEvery query runs through a four-stage retrieval strategy:
- Exact symbol lookup
- Keyword search (BM25)
- Semantic vector search (IVF index, O(1) lookup via mmap)
- Call graph expansion
Results are re-ranked via MMR and budget-allocated before being passed to the LLM with a structured CoT prompt. Answers surface related code that wasn't retrieved — reducing hallucination risk rather than hiding it.
Three binaries, one pipeline:
| Binary | Language | Role | License |
|---|---|---|---|
eulix |
Go | Orchestrator — CLI, config, retrieval pipeline, LLM integration, TUI | GPLv3 |
eulix_parser |
Rust | Static analyzer — symbols, call graphs, control flow, complexity | GPLv3 |
eulix_embed |
Python | Embedder — transformers via PyTorch, CUDA/ROCm, bucket sharding | Apache 2.0 |
Grounded answers, not guesses. Eulix builds a structured model of your codebase before answering anything. Retrieval is multi-layer and re-ranked, not a nearest-neighbor gamble.
Local-first, privacy by default. Parse, embed, and reason entirely on your machine. No code is sent anywhere unless you configure a cloud LLM.
Any LLM provider. OpenAI, Anthropic, Gemini, Ollama, LM Studio, or any OpenAI-compatible endpoint. One config line to switch.
Small models, big results. Accurate context means a local 7B model answers as well as GPT-4 on code understanding tasks. No API costs, no rate limits.
Handles real codebases. Built for multi-million LOC repos, monorepos, and legacy systems across multiple languages.
- Multi-language parsing — Python, Go, C, C++, Rust. Structural extraction, not regex over text
- PRISM call graph approximation — fast polyglot call graph resolution with documented tradeoffs
- Multi-layer retrieval — symbol → BM25 → semantic → call graph, with MMR re-ranking
- GPU acceleration — CUDA and ROCm support for embedding generation
- Any LLM provider — OpenAI · Anthropic · Gemini · Ollama · LM Studio · OpenAI-compatible
- Anti-hallucination design — surfaces retrieval gaps explicitly rather than guessing
Stable: Python · Go · C · C++ · Rust
Coming soon: TypeScript · JavaScript · Java
- Onboarding — understand what any module does without reading every file
- Debugging unfamiliar code — trace execution flow and caller/callee chains
- Refactoring — understand impact across the codebase before changing anything
- Security audits — find every caller of a sensitive function
- Architecture review — map how components interact at the call graph level
- MCP server — plug Eulix into any editor or agent via Model Context Protocol
- Call graph visualization — interactive dependency graph from PRISM output
- Doc generation — architecture-aware documentation grounded in call flow
- Code navigation — symbol jump, reference finder, caller/callee explorer
- TypeScript / JavaScript / Java support
- Go 1.23+
- Rust (stable)
- Python 3.10–3.11
uv(only for venv creation and python version management)
Install PyTorch for your platform first: https://pytorch.org/
curl -fsSL https://raw.githubusercontent.com/nurysso/eulix/main/install.sh | bashRequires Visual Studio Build Tools (C++ workload) for the Rust linker.
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/nurysso/eulix/main/install.ps1" -OutFile "$env:TEMP\install.ps1"
powershell -ExecutionPolicy Bypass -File "$env:TEMP\install.ps1"→ Full setup guide: docs/installation.md
# 1. Initialize in your project root
cd your-project
eulix init
# 2. Build the knowledge base
eulix analyze
# 3. Ask questions
eulix chat| Command | Description |
|---|---|
init |
Initialize Eulix in the current directory |
analyze |
Parse and embed the codebase, build knowledge base |
chat |
Start interactive query session |
config |
Manage configuration (LLM provider, model, paths) |
history |
Browse past queries interactively |
cache |
Manage the query cache |
embed |
Run the embedding pipeline directly |
version |
Show versions of all three components |
eulix_parser [OPTIONS]
Options:
-r, --root Project root directory
-o, --output Output path for knowledge base JSON [default: knowledge_base.json]
-t, --threads Parallel threads [default: 4]
-l, --languages Languages to parse, comma-separated or "all" [default: all]
--no-analyze Parse only, skip analysis phase (faster)
--euignore Path to custom .euignore file
-v, --verbose Verbose output
-V, --version Print version
eulix_embed <COMMAND> [OPTIONS]
Commands:
embed Generate embeddings for a knowledge base (default)
query Embed a single query string
compare Validate embeddings.bin against vectors.bin
Embed options:
-k, --kb-path Path to knowledge base JSON
-o, --output Output directory
-m, --model HuggingFace model name or local path
Supported models: sentence-transformers/all-MiniLM-L6-v2 · BAAI/bge-small-en-v1.5 · BAAI/bge-base-en-v1.5
→ Model selection guide: docs/models-to-use.md
| Doc | Description |
|---|---|
| Architecture Overview | System design and data flow |
| Parser Internals | How eulix_parser works |
| PRISM Algorithm | Call graph approximation design and tradeoffs |
| Retrieval Pipeline | Multi-layer retrieval and MMR selection |
| Query Classifier | Intent recognition and routing |
| Cache Architecture | Redis/SQL caching layer |
| Embedding Pipeline | Embedder internals |
| Parser Benchmarks | Performance numbers |
| Known Issues | Current limitations including PRISM accuracy |
| Installation Guide | Detailed platform setup |
| Model Selection | Recommended embedding and LLM models |
Documentation contributions are especially welcome — many sections need updating.
Open an issue before submitting a pull request for significant changes.
eulixandeulix_parser— GNU General Public License v3.0eulix_embed— Apache License 2.0