Ploke is a Rust-focused terminal-based application for developer-LLM collaboration. It natively parses your rust codebase into a vector-graph database and provides tools for efficient LLM search/edit functionality such as semantic search/edits, and Rust-focused tooling like a native "cargo test" tool that parses and filters test output for LLMs. Ploke focuses on providing vim-like bindings (Insert vs. Normal modes), extensive configuration through interactive overlays (model picker covers all available OpenRouter models, tool verbosity, embedding picker), and a design that invites discovery of code analysis and LLM functionality (semantic + bm25 search overlay mirrors LLM-facing code search tool).

If you want your coding LLMs to have deep comprehension of your Rust code base, you are in the right place.

Getting Started · Features · Docs (mdBook) · Troubleshoot · Contact Us

🚧 WARNING: Early Alpha 🚧

Under development, will likely not crash/panic if it tries to parse a crate with an error, or in certain known limitations or unknown bugs. Please open an issue if you discovery one, it will jump to the top of our todo list.

git clone https://github.com/josephleblanc/ploke.git
cd ploke
./install.sh

git clone https://github.com/josephleblanc/ploke.git
cd ploke
cargo build --release

This will put the ploke the <git clone dir>/target/ploke

After installation, make sure you have OPENROUTER_API_KEY set, e.g.

export OPENROUTER_API_KEY="sk-..." # OpenRouter key

Next you just go to the directory with your rust project and run ploke:

cd ~/path/to/rust/crate-or-workspace
ploke

From here you can use some commands to select a model, an embedding model, and index your codebase.

Select a model (default kimi-k2)

/model search <model>

For example:
/model search kimi

Choose an embedding model (defaults to local CPU processing with sentence-transformers currently, can be slow!)

/embedding search <model>

See all embedding models on OpenRouter here.

Generate the code graph for your codebase. By default this generates a graph from your working directory, and will index a workspace if you are in a workspace, or a crate if you are in a crate.

/index start

Now you're good to go. The next time you send a message to the LLM, ploke will automatically use semantic search on your message to find related code for quick initial context, and ploke's built-in tools for LLMs allow the model to lookup code items or semantically search the code base.

By default, the model's context window is managed throughout your conversation, but you can toggle that off with Ctrl+f.

To save the code graph for your embedded and indexed codebase, you can use:

/save db

Then later you can load it faster with:

/load <crate-name>
/load <workspace-dir-name-only>

Here are some common commands. For the full reference on available commands, use /help within ploke.

Default: kimi-k2
This opens an overlay that lets you navigate and select a model/provider. Search matches exact string, so to see all gpt-family models, search "gpt" and you'll see "gpt-5.1", "gpt-5.2", etc.

/model search <model>

For example:
/model search minimax
/model search kimi
/model search anthropic
/model search gpt

Default: local, can be slow (update coming soon, select a model if possible)
This opens an overlay for embedding models available through openrouter, e.g. codestral by searching "code" or qwen-3 by searching "q" or "qwen".

/embedding search <model>

Examples:
/embedding search code
/embedding search q
/embedding search qwen

Use the index command to generate the embeddings + perform hnsw indexing for fast lookup of code snippets:

/index start

To generate only the target crate, use:

/index start path/to/crate

We make a best-effort to keep the models safe, but ultimately it is up to you to keep them from malicious behavior we cannot foresee.

• By default, the model cannot directly edit your code.

• You can approve/deny either in the approvals overlay or by selecting the earlier message in Normal mode and using y or n, Y approves all pending and N denies all pending.

• The model is able to execute cargo test, but this command is internally managed by ploke, and only accepts arguments that are parsed into a specific set of arguments (so they never make it to the shell).

• Note that we do not currently allow the LLM any direct shell access, but this may change in the future.

We will do our very best to ensure that ploke will ask for your explicit permission before elevating permissions.

We do not collect any user data. In the future we may add an opt-in to help improve ploke, but we will never require your personal information for any reason.

That said, we do not take responsibility for information shared via API access with the models provided through this application.

Coming soon: Additional config to optionally set OpenRouter's Zero Data Retention as required

• Interactive model search with all OpenRouter models (live updates, no config required)
• Interactive embedding search with all OpenRouter embedding models (live updates, no config required)
• Natively parsed code graph (no rust-analzyer dependency required)
• Hybrid semantic + graph code search via generated code graph
• Semantic edits (LLM uses node file and module path instead of search/replace)
• Non-semantic search: BM25 keyword search
• Non-semantic edits: on failing to parse or tool failure, falls back to non-semantic (search/replace) edits
• Code changes as git patches

You can expect some of these in the next few weeks:

• UI + onboarding polish
• Forking/swapping chat branches with keybinds
• Static code analysis with type resolution
• More config options: agent profiles, skills, slash-commands
• Sub-agent support
• Natively parsed call graph
• Multi-sampling

We hope to build these in the next few months, but they are very ambitious goals and some of them are open areas of research.
User feedback may influence the direction our development takes.

• "Auto-optimize" mode, OpenEvolve-inspired
• Built-in CVE analysis
• LLM-assisted formal verification methods
• Teams/Collab support
• Swarm support with file lock semantics inspired by rust's concurrency model
• JODIE-inspired embeddings (private by default) so ploke learns your coding style

Configuration is loaded at startup from ~/.config/ploke/config.toml (optional; missing file uses defaults) and merged with environment variables (nested keys use _ separators, e.g. token_limit → TOKEN_LIMIT). LLM API keys are expected from the environment (e.g. OPENROUTER_API_KEY), not from the router section of the file.

Workspace metadata (recent roots, snapshot paths, etc.) is stored separately as workspaces.toml next to the main config (typically ~/.config/ploke/workspaces.toml; uses the XDG config-local dir, which may differ slightly by platform).

Use /model save [path] in the TUI to write the current configuration; omit --with-keys when sharing (intended for redacting secrets—embedding keys in TOML should still be treated as sensitive).

To install and run Ploke, you'll need the following tools installed on your system:

• Rust toolchain (2024 edition): Ploke is built using Rust 2024. Install Rust using rustup.

  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

  After installing, ensure your toolchain is up to date and set to the stable channel:

  rustup update
  rustup default stable

• Cargo (comes with Rust): Used for building and installing Rust projects.

• A Unix-like shell (bash, zsh, etc): The installation script (install.sh) is a Bash script.

Optional:
If you wish to install the binary to a custom location (such as $HOME/.cargo/bin), set the INSTALL_DIR environment variable when running the install script:

INSTALL_DIR="$HOME/.cargo/bin" ./install.sh

The default install location is $HOME/.local/bin if INSTALL_DIR is not specified.

Make sure the chosen INSTALL_DIR is in your PATH so the ploke command can be found.

If you do not have cargo on your PATH, the installer will print an error and exit early.
See the Rust documentation for troubleshooting.

Under construction, mdbook soon!

We are in early alpha, expect UI to be buggy sometimes (list scrolling, etc). Definitely open an issue and it will jump to the top of our todo list.

Vector embedding is computationally expensive, sadly. The best fix for this right now is to use a remote embedding service automatically available for a low cost through your OPENROUTER_API_KEY.

Try using something like:

/embedding search code

Select codestral

/index start

This is as fast as we can make it, and batches requests to the embedding provider.

Ploke is licensed under a dual-license model:

• Open Source License: You may use, modify, and redistribute Ploke under the terms of the GNU General Public License v3.0 (GPL-3.0).
• Commercial License: If you would like to use Ploke as part of a proprietary product, SaaS offering, or any commercial service without complying with GPL-3.0, you must obtain a commercial license.

To inquire about commercial licensing, please contact: 📩 team@ploke.dev