ollama launch and coding-agent integrations: Claude Code / Codex / OpenCode / Copilot CLI

Parent: Ollama integrations and ecosystem · Published reference · snapshot 2026-10-14 · skill ollama-expert/references/ollama-integrations-ecosystem.md

Also known as: ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI

↓ Facts as markdown all context files

ollama launch is a new command which sets up and runs your favorite coding tools like Claude Code, OpenCode, and Codex with local or cloud models. No environment variables or config files needed. (from ollama.com)

These notes link each claim to its source. Some citations identify archived research reports that are no longer hosted on this site. A published reference means the content is available; it does not certify independent review or accuracy.Read the editorial policy and follow the sources before relying on a claim.

Definitions

ollama launch is a new command which sets up and runs your favorite coding tools like Claude Code, OpenCode, and Codex with local or cloud models. No environment variables or config files needed. [source]
OpenCode is an open-source coding agent that runs in your terminal, reads your project, edits files, and runs commands. Ollama configures OpenCode to use local and cloud models. [source]
Claude Code + local models are not practical at this time. [source]

How it works

When launched through ollama launch codex, Ollama refreshes the model catalog and uses a dedicated Codex profile for that session. Type /model inside Codex to switch between your installed, tool-capable Ollama models without restarting. The starting model remains selected, and each model keeps its own context window, vision, and thinking settings. Pull additional models with ollama pull <model> before launching to include them in the picker. To configure without launching: [source]
When launched through `ollama launch codex`, Ollama refreshes the model catalog and uses a dedicated Codex profile for that session. [source]
* Only requests made with an Ollama model go to Ollama. ChatGPT's native models keep using their usual provider. * Ollama models are for Codex mode. Regular Chat and voice keep using their usual ChatGPT connection. * Codex manages sessions. Ollama routes model requests and compaction when Codex asks for it, but does not store ChatGPT sessions. * Web search uses Ollama's web-search service when you use an Ollama model. It requires Ollama sign-in and is limited to three calls per response. [source]
The --yes flag skips selectors, pulls the model when needed, and requires --model. Arguments after -- are passed directly to Claude Code. [source]
When executed, "Launching Claude Code with {model}..." is displayed, and Claude Code launches with environment variables automatically configured. If no model is specified, one is automatically selected from available models. [source]
Problems Occur When Connecting with Claude Code [source]
However, various problems occurred when connecting with Claude Code. [source]
In response to the instruction "write code," it returned a calculation result. When I explicitly instructed "write FizzBuzz code in TypeScript," it succeeded, but that's different from how Claude Code is naturally used. [source]
<div> <div>Command line</div> <div>Run commands with Claude Code's permission flow</div> </div> </div> [source]
The `--yes` flag skips selectors, pulls the model when needed, and requires `--model`. Arguments after `--` are passed directly to Claude Code. [source]

How-to and procedures

Run `ollama launch` in a terminal to choose a coding agent. [source]
Install Claude Code, then set your [API key](/quickstart#build-an-application) in `OLLAMA_API_KEY`. No Ollama installation required. [source]
Use `ANTHROPIC_AUTH_TOKEN` for bearer authentication. Claude settings can override shell variables. Update any base URL or credentials in those settings, then run `/status` to check the connection. [source]
Install the Codex CLI. For the ChatGPT desktop app, see ChatGPT Desktop. [source]
Use a context window of at least 64k tokens for Codex. [source]
Install the [Codex CLI](https://developers.openai.com/codex/cli/). For the ChatGPT desktop app, see [ChatGPT Desktop](/integrations/chatgpt). [source]
Use Ollama’s web search API from Claude Code. See Web search for setup and usage. [source]
Use Ollama's web search API from Claude Code. [source]
To use `codex` with Ollama, use the `--oss` flag: [source]
Add an Ollama provider to `opencode.json`: [source]
Run `droid` in a new terminal to load the new settings. [source]
Run commands with Claude Code’s permission flow [source]
Use `/loop` inside Claude Code to run a prompt or slash command on a schedule: [source]

Examples and snippets

```toml theme={"system"} — `model = "gpt-oss:120b"` … [source]
``` — `codex --profile ollama-launch` … [source]
```shell theme={"system"} — `ANTHROPIC_BASE_URL=https://ollama.com \` … [source]
```shell theme={"system"} — `ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY="" claude --model kimi` … [source]
``` — `ollama launch claude` … [source]
``` — `ollama launch claude --model qwen3.5` … [source]
```shell theme={"system"} — `ollama launch claude` … [source]
```shell theme={"system"} — `ollama launch claude --model gemma4:cloud --yes -- -p "how does this repository work?"` … [source]
```shell theme={"system"} — `ollama launch claude -- --channels plugin:telegram@claude-plugins-official` … [source]
``` — `ollama launch codex` … [source]
```shell theme={"system"} — `ollama launch copilot` … [source]
```shell theme={"system"} — `ollama launch copilot --model kimi-k2.5:cloud --yes -- -p "how does this repository work?"` … [source]
```json theme={"system"} — `"$schema": "https://opencode.ai/config.json",` … [source]
``` — `ollama launch droid --config` … [source]
```bash theme={"system"} — `ollama launch droid` … [source]
```shell theme={"system"} — `ollama launch droid --config` … [source]
```shell theme={"system"} — `export ANTHROPIC_AUTH_TOKEN=ollama # required but ignored` … [source]
``` — `codex --oss -m gpt-oss:120b` … [source]
``` — `codex --oss -m gpt-oss:120b-cloud` … [source]
```shell theme={"system"} — `ollama launch dsh` … [source]
```shell theme={"system"} — `ollama launch dsh --model qwen3.8` … [source]
```shell theme={"system"} — `ollama launch dsh --config` … [source]
```shell theme={"system"} — `ollama launch dsh -- --port 3081` … [source]
```bash theme={"system"} — `ollama launch omp` … [source]
```shell theme={"system"} — `ollama launch omp --model <model>` … [source]
```bash theme={"system"} — `ollama launch omp --config` … [source]
```shell theme={"system"} — `ollama launch pool` … [source]
```shell theme={"system"} — `ollama launch pool -- --help` … [source]
```shell theme={"system"} — `claude --model qwen3.5` … [source]
``` — `npm install -g @openai/codex` … [source]
```shell theme={"system"} — `opencode` … [source]

Measurements and reference values

The Ollama launch blog recommends glm-4.7-flash (about 23 GB VRAM at 64k context), qwen3-coder and gpt-oss:20b locally, and cloud models such as glm-4.7:cloud, minimax-m2.1:cloud, gpt-oss:120b-cloud and qwen3-coder:480b-cloud. Later docs examples name newer models, so model recommendations date quickly. [source]

Problems, failure modes and limitations

OpenCode manual setup uses `opencode.json` with provider id ollama, npm package @ai-sdk/openai-compatible, options.baseURL http://localhost:11434/v1 and a models map. OpenCode's docs say Ollama can auto-configure OpenCode (pointing to the Ollama integration page) and advise, if tool calls fail, raising Ollama's `num_ctx` (start around 16k-32k). [source]
Context length: Ollama's blog and integration pages advise at least 64k tokens for coding agents; GitHub advises at least 128k for Copilot CLI BYOK; OpenCode's docs treat `num_ctx` (16k-32k start) as the first fix when tool calls fail. Ollama's default context is too small for these agents, so raise it before launching. [source]
Negation: a hands-on test (Ollama v0.15.1, Claude Code v2.1.15, M4 32GB) found small local models impractical with Claude Code: gemma3:4b returned an API error for no tool support, qwen2.5-coder:14b printed tool calls as JSON text and took 57s, and Claude Code's tool definitions alone use about 11,000 tokens of context. The author concluded it was 'not practical at this time'. Treat launch success as setup success, not capability. [source]
Models must support tool calling (also called function calling) and streaming. If a model does not support either capability, Copilot CLI returns an error. For best results, use a model with a context window of at least 128k tokens. [source]
Claude Code tries to use tools for file operations, etc., but gemma3:4b does not support native tool calls (function calling), resulting in an error. There is a possibility of handling this with custom prompt templates, but it cannot be used as-is with Claude Code. [source]
Claude Code is designed on the premise of complex system prompts and tool calls. Since tool definitions alone use approximately 11,000 tokens worth of context, small models of 8B or less cannot correctly process this enormous context. [source]
- Ollama's current versions are in the 0.x range but no such command exists - Claude Code cannot be connected to local models through Ollama in the way described - Claude Code uses Anthropic's API and does not have a feature to swap in local models this way [source]

Comparisons and alternatives

The same problem occurred with 14B as well. Instead of writing code, it tried to create a task list, and the tool call was output as JSON text. Processing time was also slow at 57 seconds, and increasing the model size did not resolve the integration issues with Claude Code. [source]

Facts and statements

GitHub's official Copilot CLI BYOK docs list Ollama as a supported OpenAI-compatible provider. Env vars: COPILOT_PROVIDER_BASE_URL (required), COPILOT_MODEL (required, or --model), COPILOT_PROVIDER_TYPE (openai default, azure, anthropic), COPILOT_PROVIDER_API_KEY (optional; a local Ollama needs none), COPILOT_PROVIDER_WIRE_API, and COPILOT_PROVIDER_MAX_PROMPT_TOKENS / MAX_OUTPUT_TOKENS. Models must support tool calling and streaming or the CLI errors. [source]
Codex manual paths: `codex --oss` (optionally `-m <model>`), or a persistent profile `~/.codex/ollama-launch.config.toml` with model_provider "ollama-launch", base_url http://localhost:11434/v1/ and wire_api = "responses". Codex's own repo made the Responses format the default for the built-in `ollama` provider (#8798), and a third-party guide reports the chat-completions wire API was removed from Codex in February 2026, so `wire_api = "chat"` configs no longer work. [source]
ollama launch` was announced in the Ollama blog on 2026-01-23 with Claude Code, OpenCode, Codex and Droid as supported tools; the blog presents it as setup-and-run with no manual environment variables or config files, and `--config` configures a tool without launching it. [source]
Headless use: `ollama launch claude --model <m> --yes -- -p "..."` (same shape for `copilot`). `--yes` skips selectors, pulls the model if missing, and requires `--model`; everything after `--` goes straight to the underlying tool. [source]
Codex via `ollama launch codex` refreshes the model catalog and uses a dedicated Codex profile for the session; `--config` configures without launching and `--restore` removes the Ollama launch profile and generated catalog. In Codex, `/model` switches between installed tool-capable Ollama models without a restart. [source]
Copilot CLI `COPILOT_OFFLINE=true` stops contact with GitHub's servers, but it only gives full network isolation if the provider is also local; a remote COPILOT_PROVIDER_BASE_URL still receives prompts and code context. [source]
<Tabs> <Tab title="Claude Code"> ```shell theme={"system"} ollama launch claude ``` [source]
```shell theme={"system"} ollama launch codex ``` [source]
<Tab title="OpenCode"> ```shell theme={"system"} ollama launch opencode ``` [source]
For a persistent Codex CLI configuration, create `~/.codex/ollama-launch.config.toml`: [source]
[model_providers.ollama-launch] name = "Ollama" base_url = "http://localhost:11434/v1/" wire_api = "responses" [source]
ANTHROPIC_BASE_URL=https://ollama.com \ ANTHROPIC_AUTH_TOKEN="$OLLAMA_API_KEY" \ ANTHROPIC_API_KEY="" \ claude --model glm-5.3-flash [source]
ChatGPT Desktop includes Codex, OpenAI's desktop coding agent. Ollama adds compatible local and cloud models to Codex's model picker alongside ChatGPT's native models. [source]
Claude Code reads your codebase, edits files, and runs commands. Ollama connects Claude Code to local and cloud models through its Anthropic-compatible API. [source]
ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY="" claude --model kimi-k2.7-code:cloud [source]
Ollama connects Claude Code to local and cloud models through its Anthropic-compatible API. [source]
<Card title="ChatGPT Desktop" icon="https://mintcdn.com/ollama-9269c548/HSXjoAUgp7vt8Q9k/images/launch-icons/chatgpt.svg?fit=max&auto=format&n=HSXjoAUgp7vt8Q9k&q=85&s=c1abef5f71760198760f4cb7669ef143" href="/integrations/chatgpt"> Use Ollama models in Codex mode. </Card> </CardGroup> [source]
ollama launch copilot --model kimi-k2.5:cloud [source]
ollama launch copilot --model kimi-k2.5:cloud --yes -- -p "how does this repository work?" [source]
{ "$schema": "https://opencode.ai/config.json", "provider": { "ollama": { "npm": "@ai-sdk/openai-compatible", "name": "Ollama", "options": { "baseURL": "http://localhost:11434/v1" }, "models": { "qwen3.5": { "name": "qwen3.5" } } } } } [source]
ollama launch opencode starts OpenCode with an inline config for the selected Ollama model. It does not overwrite ~/.config/opencode/opencode.json; existing OpenCode settings still apply. Models defined only in opencode.json do not appear in the ollama launch model picker. See OpenCode’s config precedence. Previous [source]
ollama launch claude --model gemma4:cloud --yes -- -p "how does this repository work?" [source]
ollama launch claude -- --channels plugin:telegram@claude-plugins-official [source]
Ollama v0.15 does not exist, and there is no `ollama launch claude` command. [source]
With the release of Ollama v0.15 on January 23, 2026, the ollama launch claude command was added. This makes it very easy to set up Claude Code to run on local models. I was excited and tested it with the expectation that "maybe we can finally use Claude Code with a local LLM," but to get straight to the point, it was not practical at this time. [source]
In v0.15, the ollama launch claude command was added, eliminating the need to set environment variables. [source]
ollama launch claude --model qwen2.5-coder:1.5b [source]
Ollama can automatically configure itself for OpenCode. See the Ollama integration docs for details. [source]
`ollama launch opencode` starts OpenCode with an inline config for the selected Ollama model. It does not overwrite `~/.config/opencode/opencode.json`; existing OpenCode settings still apply. [source]
Models defined only in `opencode.json` do not appear in the `ollama launch` model picker. [source]
model = "gpt-oss:120b" model_provider = "ollama-launch" model_catalog_json = "~/.codex/model.json" [source]
You can configure opencode to use local models through Atomic Chat, a desktop application that runs local LLMs behind an OpenAI-compatible API server (default endpoint http://127.0.0.1:1337/v1). [source]
Connect Anthropic clients and tools such as Claude Code to Ollama. Ollama supports a subset of the [Anthropic Messages API](https://platform.claude.com/docs/en/api/http/messages/create). [source]
<Note>Use a context window of at least 64k tokens for Codex.</Note> [source]
Ollama offers to install Claude Code if needed. See [Claude Code](/integrations/claude-code) for details. </Tab> [source]
Ollama offers to install OpenCode if needed. See [OpenCode](/integrations/opencode) for details. </Tab> </Tabs> [source]
Copilot CLI connects to Ollama using the OpenAI-compatible API via environment variables. [source]
You can configure Copilot CLI to include models from an LLM provider of your choice—using BYOK (Bring Your Own Key)—in addition to the GitHub-hosted models. This lets you connect to OpenAI-compatible endpoints, Azure OpenAI, or Anthropic, including locally running models such as Ollama. [source]
GitHub Copilot CLI is GitHub’s AI coding agent for the terminal. It can understand your codebase, make edits, run commands, and help you build software faster. Open models can be used with Copilot CLI through Ollama, enabling you to use models such as qwen3.5, glm-5.3:cloud, kimi-k3:cloud See all supported models here. [source]
Codex web-search requests sent through the Ollama profile are executed by Ollama for both local and cloud models. Sign in with ollama signin to use the web-search service. To disable web search for a Codex session: [source]
1. Open the Ollama desktop app and select **Apps**. 2. Toggle **ChatGPT (Desktop)** to On. 3. Follow the setup prompts. If ChatGPT is already open, Ollama asks to restart it before the new models appear. 4. Open the ChatGPT desktop app and use Codex mode. [source]
Type `/model` inside Codex to switch between your installed, tool-capable Ollama models without restarting. The starting model remains selected, and each model keeps its own context window, vision, and thinking settings. Pull additional models with `ollama pull <model>` before launching to include them in the picker. [source]
Codex web-search requests sent through the Ollama profile are executed by Ollama for both local and cloud models. Sign in with `ollama signin` to use the web-search service. [source]
Ollama configures OpenCode to use local and cloud models. [source]
* [Claude Desktop](/integrations/claude-desktop) — use Ollama models in Claude. * [ChatGPT Desktop](/integrations/chatgpt) — use Ollama models in Codex mode. Regular Chat and voice use your usual ChatGPT connection. [source]
<CardGroup> <Card title="Claude Code" icon="https://mintcdn.com/ollama-9269c548/VdS6E00liu8o_Gkj/images/launch-icons/claude-code.svg?fit=max&auto=format&n=VdS6E00liu8o_Gkj&q=85&s=edd8f01fa1844a0eca0a9e00be74a8a3" href="/integrations/claude-code"> Read code, edit files, and run commands. </Card> [source]
<Card title="OpenCode" icon="https://mintcdn.com/ollama-9269c548/VdS6E00liu8o_Gkj/images/launch-icons/opencode.svg?fit=max&auto=format&n=VdS6E00liu8o_Gkj&q=85&s=ffa7d783e8ddf476a376ebbedaa064ae" href="/integrations/opencode"> Edit and run code from your terminal. </Card> [source]
See [Codex CLI](/integrations/codex) for setup. </Tab> [source]
For more tools, see [Integrations](/integrations). To connect an agent directly with an API key, see [Claude Code](/integrations/claude-code#connect-directly-to-ollama-cloud). [source]
export ANTHROPIC_AUTH_TOKEN=ollama export ANTHROPIC_API_KEY="" export ANTHROPIC_BASE_URL=http://localhost:11434 [source]
export ANTHROPIC_BASE_URL=http://localhost:11434 export ANTHROPIC_API_KEY=ollama export ANTHROPIC_MODEL=qwen2.5-coder:1.5b [source]
On macOS, open the [Ollama app](https://ollama.com/download) and select **Apps** in the sidebar. Connect Claude or ChatGPT. [source]
ollama launch Command Added in v0.15 [source]
Ollama Blog: ollama launch [source]
Then run `ollama launch dsh`. On Windows, install Node.js for Windows. [source]
OpenCode requires a context length of 64k or higher. See Context length for more information. [source]
OpenCode uses the AI SDK and Models.dev to support 75+ LLM providers and it supports running local models. [source]
If tool calls aren’t working, try increasing num_ctx in Ollama. Start around 16k - 32k. [source]
GitHub Copilot CLI is GitHub's AI coding agent for the terminal. It can understand your codebase, make edits, run commands, and help you build software faster. [source]
[OpenCode](https://opencode.ai) is an open-source coding agent that runs in your terminal, reads your project, edits files, and runs commands. [source]
<Note>OpenCode requires a context length of 64k or higher. See [Context length](/context-length) for more information.</Note> [source]
The following example configures `qwen3-coder` for use with Droid. [source]
I tried running Claude Code locally with Ollama v0.15 [source]
If you have a genuine question about Ollama, local models, or Claude Code's actual capabilities, I am happy to help with accurate information. [source]
With Ollama v0.14.0 released on January 12, 2026, a /v1/messages endpoint compatible with the Anthropic API was added. By setting environment variables, Claude Code can connect to local Ollama. [source]
While integration with Claude Code is difficult, code generation with Ollama alone is sufficiently practical. [source]
Ollama v0.14.0's Anthropic API compatibility mode works technically, but reproducing the full functionality of Claude Code with local models is currently difficult. [source]
Ollama Blog: Claude Code with Anthropic API compatibility [source]
You can configure opencode to use local models through Ollama. [source]
Ollama works well with OpenAI’s Codex tool. Add the following configuration to ~/.codex/config.toml [source]
Open models can be used with Copilot CLI through Ollama, enabling you to use models such as `qwen3.5`, `glm-5.3:cloud`, `kimi-k3:cloud` See all supported models [here](https://ollama.com/search). [source]
"name": "Ollama (local)", [source]
The --yes flag auto-pulls the model, skips selectors, and requires --model to be specified. Arguments after -- are passed directly to Copilot CLI. [source]
curl -fsSL https://opencode.ai/install | bash [source]
codex --oss -m gpt-oss:120b [source]
codex --oss -m gpt-oss:120b-cloud [source]
Claude Code prompts for permission on most actions. To allow the bot to work autonomously, configure permission rules or pass --dangerously-skip-permissions in an isolated environment. See the plugin README for setup instructions. [source]
You configure your model provider by setting environment variables before starting Copilot CLI. [source]
COPILOT_PROVIDER_MODEL_IDThe well-known model name. Copilot CLI uses this value to identify model capabilities and token limits. [source]
You can run Copilot CLI in offline mode to prevent it from contacting GitHub's servers. This is designed for isolated environments where the CLI should communicate only with your local or on-premises model provider. [source]
No file was actually created; only the JSON of the tool call was displayed. Moreover, "TodoWrite" is a task management tool in Claude Code and is not used for code generation. Small models "recognize" Claude Code's tool definitions but are unable to select and execute the correct tool. [source]
Claude Code runs locally ⚠️ Can connect, but doesn't work properly [source]
You can configure opencode to use local models through llama.cpp’s llama-server utility [source]
You can configure opencode to use local models through LM Studio. [source]
* Use Codex from a terminal with [Codex CLI](/integrations/codex). * Connect other desktop apps from [Claude Desktop](/integrations/claude-desktop). [source]
[Claude Code](https://code.claude.com/docs/en/overview) reads your codebase, edits files, and runs commands. [source]
Connect a Telegram bot to your Claude Code session. Install the [Telegram plugin](https://github.com/anthropics/claude-plugins-official), create a bot with [@BotFather](https://t.me/BotFather), then launch Claude Code: [source]
Claude Code prompts for permission on most actions. To allow the bot to work autonomously, configure [permission rules](https://code.claude.com/docs/en/permissions) or pass `--dangerously-skip-permissions` in an isolated environment. [source]
<p>1. Install Claude Code</p> [source]
<p>3. Run Claude Code</p> [source]
<CodeGroup> ```shell macOS / Linux (Homebrew) theme={"system"} brew install copilot-cli ``` [source]
The `--yes` flag auto-pulls the model, skips selectors, and requires `--model` to be specified. Arguments after `--` are passed directly to Copilot CLI. [source]
<p>1. Install OpenCode</p> [source]
<CodeGroup> ```shell macOS / Linux theme={"system"} curl -fsSL https://opencode.ai/install | bash ``` [source]

Related concepts

ollama — is a related of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
Claude Code — is a instance of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
ollama launch — is a synonym of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
Codex — is a instance of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
OpenCode — is a instance of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
coding agent — is a hypernym of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
Copilot CLI — is a instance of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
localhost — is a problem of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
anthropic compatibility — is a dependent of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
openai compatibility — is a dependent of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
num_ctx — is a problem of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
ollama signin — is a part of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
ChatGPT — is a contrast of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
tool calling — is a dependent of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
Droid — is a instance of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
OLLAMA_HOST — is a part of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI
client library — is a hypernym of ollama launch and coding-agent integrations: Claude Code, Codex, OpenCode, Copilot CLI

Children

No children recorded.

← the whole tree · 3D view· how to read this page