| *develop.txt* Nvim |
|
|
|
|
| NVIM REFERENCE MANUAL |
|
|
|
|
| Development of Nvim *development* *dev* |
|
|
| This reference describes design constraints and guidelines, for developing |
| Nvim applications or Nvim itself. See |dev-arch| for discussion of Nvim's |
| architecture and internal concepts. |
|
|
| Nvim is free and open source. Everybody is encouraged to contribute. |
| https://github.com/neovim/neovim/blob/master/CONTRIBUTING.md |
|
|
| Type |gO| to see the table of contents. |
|
|
| ============================================================================== |
| Design goals *design-goals* |
|
|
| Most important things come first (roughly). Some items conflict; this is |
| intentional. A balance must be found. |
|
|
|
|
| NVIM IS... IMPROVED *design-improved* |
|
|
| The Neo bits of Nvim should make it a better Vim, without becoming a |
| completely different editor. |
| - In matters of taste, prefer Vim/Unix tradition. If there is no relevant |
| Vim/Unix tradition, consider the "common case". |
| - There is no limit to the features that can be added. Select new features |
| based on (1) what users ask for, (2) how much effort it takes to implement |
| and (3) someone actually implementing it. |
| - Backwards compatibility is a feature. The RPC API in particular should |
| never break. |
|
|
|
|
| NVIM IS... WELL DOCUMENTED *design-documented* |
|
|
| - A feature that isn't documented is a useless feature. A patch for a new |
| feature must include the documentation. |
| - Documentation should be comprehensive and understandable. Use examples. |
| - Don't make the text unnecessarily long. Less documentation means that an |
| item is easier to find. |
|
|
|
|
| NVIM IS... FAST AND SMALL *design-speed-size* |
|
|
| Keep Nvim small and fast. This directly affects versatility and usability. |
| - Computers are becoming faster and bigger each year. Vim can grow too, but |
| no faster than computers are growing. Keep Vim usable on older systems. |
| - Many users start Vim from a shell very often. Startup time must be short. |
| - Commands must work efficiently. The time they consume must be as small as |
| possible. Useful commands may take longer. |
| - Don't forget that some people use Vim over a slow connection. Minimize the |
| communication overhead. |
| - Vim is a component among other components. Don't turn it into a massive |
| application, but have it work well together with other programs |
| ("composability"). |
|
|
|
|
| NVIM IS... MAINTAINABLE *design-maintain* |
|
|
| - The source code should not become a mess. It should be reliable code. |
| - Use comments in a useful way! Quoting the function name and argument names |
| is NOT useful. Do explain what they are for. |
| - Porting to another platform should be made easy, without having to change |
| too much platform-independent code. |
| - Use the object-oriented spirit: Put data and code together. Minimize the |
| knowledge spread to other parts of the code. |
|
|
|
|
| NVIM IS... NOT *design-not* |
|
|
| Nvim is not an operating system; instead it should be composed with other |
| tools or hosted as a component. Marvim once said: "Unlike Emacs, Nvim does not |
| include the kitchen sink... but it's good for plumbing." |
|
|
|
|
| ============================================================================== |
| Developer guidelines *dev-guidelines* |
|
|
|
|
| PROVIDERS *dev-provider* |
|
|
| A primary goal of Nvim is to allow extension of the editor without special |
| knowledge in the core. Some core functions are delegated to "providers" |
| implemented as external scripts. |
|
|
| Examples: |
|
|
| 1. In the Vim source code, clipboard logic accounts for more than 1k lines of |
| C source code (ui.c), to perform two tasks that are now accomplished with |
| shell commands such as xclip or pbcopy/pbpaste. |
|
|
| 2. Python scripting support: Vim has three files dedicated to embedding the |
| Python interpreter: if_python.c, if_python3.c and if_py_both.h. Together |
| these files sum about 9.5k lines of C source code. In contrast, Nvim Python |
| scripting is performed by an external host process implemented in ~2k lines |
| of Python. |
|
|
| The provider framework invokes Vimscript from C. It is composed of two |
| functions in eval.c: |
|
|
| - eval_call_provider({name}, {method}, {arguments}, {discard}): Calls |
| `provider#{name}#Call` with {method} and {arguments}. If {discard} is true, any |
| value returned by the provider will be discarded and empty value will be |
| returned. |
| - eval_has_provider({name}): Checks the `g:loaded_{name}_provider` variable |
| which must be set to 2 by the provider script to indicate that it is |
| "enabled and working". Called by |has()| to check if features are available. |
|
|
| For example, the Python provider is implemented by the |
| "autoload/provider/python.vim" script, which sets `g:loaded_python_provider` |
| to 2 only if a valid external Python host is found. Then `has("python")` |
| reflects whether Python support is working. |
|
|
| *provider-reload* |
| Sometimes a GUI or other application may want to force a provider to |
| "reload". To reload a provider, undefine its "loaded" flag, then use |
| |:runtime| to reload it: >vim |
|
|
| :unlet g:loaded_clipboard_provider |
| :runtime autoload/provider/clipboard.vim |
|
|
|
|
| DOCUMENTATION *dev-doc* |
|
|
| - "Just say it". Avoid mushy, colloquial phrasing in all documentation |
| (docstrings, user manual, website materials, newsletters, …). Don't mince |
| words. Personality and flavor, used sparingly, are welcome--but in general, |
| optimize for the reader's time and energy: be "precise yet concise". |
| - Prefer the active voice: "Foo does X", not "X is done by Foo". |
| - "The words you choose are an essential part of the user experience." |
| https://developer.apple.com/design/human-interface-guidelines/writing |
| - "...without being overly colloquial or frivolous." |
| https://developers.google.com/style/tone |
| - Write docstrings (as opposed to inline comments) with present tense ("Gets"), |
| not imperative ("Get"). This tends to reduce ambiguity and improve clarity |
| by describing "What" instead of "How". > |
| ✅ OK: |
| /// Gets a highlight definition. |
| ❌ NO: |
| /// Get a highlight definition. |
| - Avoid starting docstrings with "The" or "A" unless needed to avoid |
| ambiguity. This is a visual aid and reduces noise. > |
| ✅ OK: |
| /// @param dirname Path fragment before `pend` |
| ❌ NO: |
| /// @param dirname The path fragment before `pend` |
| - Vim differences: |
| - Do not prefix help tags with "nvim-". Use |vim_diff.txt| to catalog |
| differences from Vim; no other distinction is necessary. |
| - If a Vim feature is removed, delete its help section and move its tag to |
| |vim_diff.txt|. |
| - Mention deprecated features in |deprecated.txt| and delete their old doc. |
| - Use consistent language. |
| - "terminal" in a help tag always means "the embedded terminal emulator", |
| not "the user host terminal". |
| - Use "tui-" to prefix help tags related to the host terminal, and "TUI" |
| in prose if possible. |
| - Rough guidelines on where Lua documentation should end up: |
| - Nvim API functions `vim.api.nvim_*` should be in `api.txt`. |
| - If the module is big and not relevant to generic and lower-level Lua |
| functionality, then it's a strong candidate for separation. Example: |
| `treesitter.txt` |
| - Otherwise, add them to `lua.txt` |
|
|
| Documentation format ~ |
|
|
| For Nvim-owned docs, use the following strict subset of "vimdoc" to ensure |
| the help doc renders nicely in other formats (such as HTML: |
| https://neovim.io/doc/user ). |
|
|
| Strict "vimdoc" subset: |
|
|
| - Use lists (like this!) prefixed with "-" or "•", for adjacent lines that you |
| don't want to auto-wrap. Lists are always rendered with "flow" layout |
| (soft-wrapped) instead of preformatted (hard-wrapped) layout common in |
| legacy :help docs. |
| - Limitation: currently the parser https://github.com/neovim/tree-sitter-vimdoc |
| does not understand numbered listitems, so use a bullet symbol (- or •) |
| before numbered items, e.g. "• 1." instead of "1.". |
| - Separate blocks (paragraphs) of content by a blank line. |
| - Do not use indentation in random places—that prevents the page from using |
| "flow" layout. If you need a preformatted section, put it in |
| a |help-codeblock| starting with ">". |
| - Parameters and fields are documented as `{foo}`. |
| - Optional parameters and fields are documented as `{foo}?`. |
|
|
| C docstrings ~ |
|
|
| Nvim API documentation lives in the source code, as docstrings (doc |
| comments) on the function definitions. The |api| :help is generated |
| from the docstrings defined in src/nvim/api/*.c. |
|
|
| Docstring format: |
| - Lines start with `///` |
| - Special tokens start with `@` followed by the token name: |
| `@note`, `@param`, `@return` |
| - Markdown is supported. |
| - Tags are written as `[tag]()`. |
| - References are written as `[tag]` |
| - Use ``` for code samples. |
| Code samples can be annotated as `vim` or `lua` |
|
|
| Example: the help for |nvim_open_win()| is generated from a docstring defined |
| in src/nvim/api/win_config.c like this: > |
|
|
| /// Opens a new window. |
| /// ... |
| /// |
| /// Example (Lua): window-relative float |
| /// |
| /// ```lua |
| /// vim.api.nvim_open_win(0, false, { |
| /// relative='win', |
| /// row=3, |
| /// col=3, |
| /// width=12, |
| /// height=3, |
| /// }) |
| /// ``` |
| /// |
| /// @param buffer Buffer to display |
| /// @param enter Enter the window |
| /// @param config Map defining the window configuration. Keys: |
| /// - relative: Sets the window layout, relative to: |
| /// - "editor" The global editor grid. |
| /// - "win" Window given by the `win` field. |
| /// - "cursor" Cursor position in current window. |
| /// ... |
| /// @param[out] err Error details, if any |
| /// |
| /// @return Window handle, or 0 on error |
|
|
|
|
| Lua docstrings ~ |
| *dev-lua-doc* |
| Lua documentation lives in the source code, as docstrings on the function |
| definitions. The |lua-vim| :help is generated from the docstrings. |
|
|
| Docstring format: |
| - Use LuaCATS annotations: https://luals.github.io/wiki/annotations/ |
| - Markdown is supported. |
| - Tags are written as `[tag]()`. |
| - References are written as `[tag]` |
| - Use ``` for code samples. |
| Code samples can be annotated as `vim` or `lua` |
| - Use `@since <api-level>` to note the |api-level| when the function became |
| "stable". If `<api-level>` is greater than the current stable release (or |
| 0), it is marked as "experimental". |
| - See scripts/util.lua for the mapping of api-level to Nvim version. |
| - Use `@nodoc` to prevent documentation generation. |
| - Use `@inlinedoc` to inline `@class` blocks into `@param` blocks. |
| E.g. >lua |
| --- Object with fields: |
| --- @class myOpts |
| --- @inlinedoc |
| --- |
| --- Documentation for some field |
| --- @field somefield? integer |
|
|
| --- @param opts? myOpts |
| function foo(opts) |
| end |
| < |
|
|
| Will be rendered as: >vimdoc |
|
|
| foo({opts}) |
|
|
| Parameters: |
| - {opts}? (table) Object with the fields: |
| - {somefield}? (integer) Documentation |
| for some field |
| < |
| - Files declared as `@meta` are only used for typing and documentation (similar to "*.d.ts" typescript files). |
|
|
| Example: the help for |vim.paste()| is generated from a docstring decorating |
| vim.paste in runtime/lua/vim/_editor.lua like this: > |
|
|
| --- Paste handler, invoked by |nvim_paste()| when a conforming UI |
| --- (such as the |TUI|) pastes text into the editor. |
| --- |
| --- Example: To remove ANSI color codes when pasting: |
| --- |
| --- ```lua |
| --- vim.paste = (function() |
| --- local overridden = vim.paste |
| --- ... |
| --- end)() |
| --- ``` |
| --- |
| --- @since 12 |
| --- @see |paste| |
| --- |
| --- @param lines ... |
| --- @param phase ... |
| --- @returns false if client should cancel the paste. |
|
|
|
|
| STDLIB DESIGN GUIDELINES *dev-lua* |
|
|
| See also |dev-naming|. |
|
|
| - Keep the core Lua modules |lua-stdlib| simple. Avoid elaborate OOP or |
| pseudo-OOP designs. Plugin authors just want functions to call, not a big, |
| fancy inheritance hierarchy. |
| - Avoid requiring or returning special objects in the Nvim stdlib. Plain |
| tables or values are easier to serialize, easier to construct from literals, |
| easier to inspect and print, and inherently compatible with all Lua plugins. |
| (This guideline doesn't apply to opaque, non-data objects like `vim.cmd`.) |
| - stdlib functions should follow these common patterns: |
| - Return |lua-result-or-message| (`any|nil,nil|string`) to communicate |
| failure, or choose from |dev-error-patterns| when appropriate. |
| - Accept iterable instead of only table. |
| - Note: in some cases iterable doesn't make sense, e.g. spair() sorts the |
| input by definition, so there is no reason for it to accept an iterable, |
| because the input needs to be "reified"; it can't operate on a "stream". |
| - Return an iterable (generator) instead of table, if possible. |
| - Mimic the pairs() or ipairs() interface if the function is intended for |
| use in a |for-in| loop. |
|
|
| *dev-error-patterns* |
| To communicate failure to a consumer, choose from these patterns (in order of |
| preference): |
| 1. `retval, errmsg` |
| - When failure is normal, or when it is practical for the consumer to |
| continue (fallback) in some other way. See |lua-result-or-message|. |
| 2. optional result, no errormsg |
| - Special case of 1. When there is only a single case of "doesn't exist" |
| (e.g. cache lookup, dict lookup). |
| 3. `error("no luck")` |
| - For invalid state ("must not happen"), when failure is exceptional, or at |
| a low level where the consumers are unlikely to handle it in a meaningful |
| way. Advantage is that propagation happens for free and it's harder to |
| accidentally swallow errors. (E.g. using |
| `uv_handle/pipe:write()` without checking return values is common.) |
| 4. `on_error` callback |
| - For async and "visitors" traversing a graph, where many errors may be |
| collected while work continues. |
| 5. `vim.notify` (sometimes with optional `opts.silent` (async, visitors ^)) |
| - High-level / application-level messages. End-user invokes these directly. |
|
|
| *dev-patterns* |
| Interface conventions ~ |
|
|
| Where possible, these patterns apply to _both_ Lua and the API: |
|
|
| - When accepting a buffer id, etc., 0 means "current buffer", nil means "all |
| buffers". Likewise for window id, tabpage id, etc. |
| - Examples: |vim.lsp.codelens.clear()| |vim.diagnostic.enable()| |
| - Any function signature that accepts a callback (example: |table.foreach()|) |
| should place it as the LAST parameter (after opts), if possible (or ALWAYS |
| for "continuation callbacks"—functions called exactly once). |
| - Improves readability by placing the less "noisy" arguments near the start. |
| - Consistent with luv. |
| - Useful for future async lib which transforms functions of the form |
| `function(<args>, cb(<ret)>))` => `function(<args>) -> <ret>`. |
| - Example: >lua |
| -- ✅ OK: |
| filter(…, opts, function() … end) |
| -- ❌ NO: |
| filter(function() … end, …, opts) |
| -- ❌ NO: |
| filter(…, function() … end, opts) |
| - "Enable" ("toggle") interface and behavior: |
| - `enable(…, nil)` and `enable(…, {buf=nil})` are synonyms and control the |
| the "global" enablement of a feature. |
| - `is_enabled(nil)` and `is_enabled({buf=nil})`, likewise, query the |
| global state of the feature. |
| - `enable(…, {buf: number})` sets a buffer-local "enable" flag. |
| - `is_enabled({buf: number})`, likewise, queries the buffer-local state of |
| the feature. |
| - See |vim.lsp.inlay_hint.enable()| and |vim.lsp.inlay_hint.is_enabled()| |
| for a reference implementation of these "best practices". |
| - NOTE: open questions: https://github.com/neovim/neovim/issues/28603 |
| - Transformation functions should also have "filter" functionality (when |
| appropriate): when the function returns a nil value it excludes (filters |
| out) its input, else the transformed value is used. |
| - Example: See the format() field of |vim.diagnostic.Opts.Float|. |
|
|
| API DESIGN GUIDELINES *dev-api* |
|
|
| See also |dev-naming|. |
|
|
| - When adding an API, check the following: |
| - What precedents did you draw from? How does your solution compare to them? |
| - Does your new API allow future expansion? How? Or why not? |
| - Is the new API similar to existing APIs? Do we need to deprecate the old ones? |
| - Did you cross-reference related concepts in the docs? |
| - Avoid "mutually exclusive" parameters--via constraints or limitations, if |
| necessary. For example nvim_create_autocmd() has mutually exclusive |
| "callback" and "command" args; but the "command" arg could be eliminated by |
| simply not supporting Vimscript function names, and treating a string |
| "callback" arg as an Ex command (which can call Vimscript functions). The |
| "buffer" arg could also be eliminated by treating a number "pattern" as |
| a buffer number. |
| - Avoid functions that depend on cursor position, current buffer, etc. Instead |
| the function should take a position parameter, buffer parameter, etc. |
|
|
| Where things go ~ |
|
|
| - API (libnvim/RPC): exposes low-level internals, or fundamental things (such |
| as `nvim_exec_lua()`) needed by clients or C consumers. |
| - Lua stdlib = high-level functionality that builds on top of the API. |
|
|
| NAMING GUIDELINES *dev-naming* |
|
|
| Naming is exceedingly important: the name of a thing is the primary interface |
| for uses it, discusses it, searches for it, shares it... Consistent |
| naming in the stdlib, API, and UI helps both users and developers discover and |
| intuitively understand related concepts ("families"), and reduces cognitive |
| burden. Discoverability encourages code re-use and likewise avoids redundant, |
| overlapping mechanisms, which reduces code surface-area, and thereby minimizes |
| bugs... |
|
|
| Naming conventions ~ |
|
|
| In general, look for precedent when choosing a name, that is, look at existing |
| (non-deprecated) functions. In particular, see below... |
|
|
| *dev-name-common* |
| Use existing common {verb} names (actions) if possible: |
| - add: Appends or inserts into a collection |
| - attach: Listens to something to get events from it (TODO: rename to "on"?) |
| - call: Calls a function |
| - cancel: Cancels or dismisses an event or interaction, typically |
| user-initiated and without error. (Compare "abort", which |
| cancels and signals error/failure.) |
| - clear: Clears state but does not destroy the container |
| - create: Creates a new (non-trivial) thing (TODO: rename to "def"?) |
| - del: Deletes a thing (or group of things) |
| - detach: Dispose attached listener (TODO: rename to "un"?) |
| - enable: Enables/disables functionality. Signature should be |
| `enable(enable?:boolean, filter?:table)`. |
| - eval: Evaluates an expression |
| - exec: Executes code, may return a result |
| - fmt: Formats |
| - get: Gets things. Two variants (overloads): |
| 1. `get<T>(id: int): T` returns one item. |
| 2. `get<T>(filter: dict): T[]` returns a list. |
| - has: Checks for the presence of an item, feature, etc. |
| - inspect: Presents a high-level, often interactive, view |
| - is_enabled: Checks if functionality is enabled. |
| - open: Opens something (a buffer, window, …) |
| - parse: Parses something into a structured form |
| - set: Sets a thing (or group of things) |
| - start: Spin up a long-lived process. Prefer "enable" except when |
| "start" is obviously more appropriate. |
| - stop: Inverse of "start". Teardown a long-lived process. |
| - try_{verb}: Best-effort operation, failure returns null or error obj |
|
|
| Do NOT use these deprecated verbs: |
| - contains: Prefer "has". |
| - disable: Prefer `enable(enable: boolean)`. |
| - exit: Prefer "cancel" (or "stop" if appropriate). |
| - is_disabled: Prefer `is_enabled()`. |
| - list: Redundant with "get" |
| - notify: Redundant with "print", "echo" |
| - show: Redundant with "print", "echo" |
| - toggle: Prefer `enable(not is_enabled())`. |
|
|
| Use consistent names for {topic} in API functions: buffer is called "buf" |
| everywhere, not "buffer" in some places and "buf" in others. |
| - buf: Buffer |
| - chan: |channel| |
| - cmd: Command |
| - cmdline: Command-line UI or input |
| - fn: Function |
| - hl: Highlight |
| - pos: Position |
| - proc: System process |
| - tabpage: Tabpage |
| - win: Window |
|
|
| Do NOT use these deprecated nouns: |
| - buffer Use "buf" instead |
| - callback Use on_foo instead |
| - command Use "cmd" instead |
| - window Use "win" instead |
|
|
| *dev-name-events* |
| Use the "on_" prefix to name event-handling callbacks and also the interface for |
| "registering" such handlers (on_key). The dual nature is acceptable to avoid |
| a confused collection of naming conventions for these related concepts. |
|
|
| Editor |events| (autocommands) are historically named like: > |
| {Noun}{Event} |
|
|
| Use this format to name API (RPC) events: > |
| nvim_{noun}_{event-name}_event |
|
|
| Example: > |
| nvim_buf_changedtick_event |
| < |
| *dev-api-name* |
| Use this format to name new RPC |API| functions: > |
| nvim_{topic}_{verb}_{arbitrary-qualifiers} |
|
|
| Do not add new nvim_buf/nvim_win/nvim_tabpage APIs, unless you are certain the |
| concept will NEVER be applied to more than one "scope". That is, {topic} |
| should be the TOPIC ("ns", "extmark", "option", …) that acts on the scope(s) |
| (buf/win/tabpage/global), it should NOT be the scope. Instead the scope should |
| be a parameter (typically manifest as mutually-exclusive buf/win/… flags like |
| |nvim_get_option_value()|, or less commonly as a `scope: string` field like |
| |nvim_get_option_info2()|). |
|
|
| - Example: `nvim_get_keymap('v')` operates in a global context (first |
| parameter is not a Buffer). The "get" verb indicates that it gets anything |
| matching the given filter parameter. A "list" verb is unnecessary because |
| `nvim_get_keymap('')` (empty filter) returns all items. |
| - Example: `nvim_buf_del_mark` acts on a `Buffer` object (the first parameter) |
| and uses the "del" {verb}. |
|
|
| *dev-namespace-name* |
| Use namespace names like `nvim.foo.bar`: > |
| vim.api.nvim_create_namespace('nvim.lsp.codelens') |
| < |
|
|
| *dev-augroup-name* |
| Use autocommand group names like `nvim.foo.bar`: > |
| vim.api.nvim_create_augroup('nvim.treesitter.dev') |
| < |
|
|
| INTERFACE PATTERNS *dev-api-patterns* |
|
|
| Prefer adding a single `nvim_{topic}_{verb}_…` interface for a given topic. |
|
|
| Example: > |
|
|
| nvim_ns_add( |
| ns_id: int, |
| filter: { |
| handle: integer (buf/win/tabpage id) |
| scope: "global" | "win" | "buf" | "tabpage" |
| } |
| ): { ok: boolean } |
|
|
| nvim_ns_get( |
| ns_id: int, |
| filter: { |
| handle: integer (buf/win/tabpage id) |
| scope: "global" | "win" | "buf" | "tabpage" |
| } |
| ): { ids: int[] } |
|
|
| nvim_ns_del( |
| ns_id: int, |
| filter: { |
| handle: integer (buf/win/tabpage id) |
| scope: "global" | "win" | "buf" | "tabpage" |
| } |
| ): { ok: boolean } |
|
|
|
|
| Anti-Example: |
|
|
| Creating separate `nvim_xx`, `nvim_buf_xx`, `nvim_win_xx`, and |
| `nvim_tabpage_xx`, functions all for the same `xx` topic, requires 4x the |
| amount of documentation, tests, boilerplate, and interfaces, which users must |
| comprehend, maintainers must maintain, etc. Thus the following is NOT |
| recommended (compare these 12(!) functions to the above 3 functions): > |
|
|
| nvim_add_ns(…) |
| nvim_buf_add_ns(…) |
| nvim_win_add_ns(…) |
| nvim_tabpage_add_ns(…) |
| nvim_del_ns(…) |
| nvim_buf_del_ns(…) |
| nvim_win_del_ns(…) |
| nvim_tabpage_del_ns(…) |
| nvim_get_ns(…) |
| nvim_buf_get_ns(…) |
| nvim_win_get_ns(…) |
| nvim_tabpage_get_ns(…) |
|
|
| API-CLIENT *dev-api-client* |
|
|
| *api-client* |
| API clients wrap the Nvim |API| to provide idiomatic "SDKs" for their |
| respective platforms (see |jargon|). You can build a new API client for your |
| favorite platform or programming language. |
|
|
| List of API clients: |
| https://github.com/neovim/neovim/wiki/Related-projects#api-clients |
|
|
| *node-client* *pynvim* |
| These clients can be considered the "reference implementation" for API clients: |
| - https://github.com/neovim/node-client |
| - https://github.com/neovim/pynvim |
|
|
| Standard Features ~ |
|
|
| - API clients exist to hide msgpack-rpc details. The wrappers can be |
| automatically generated by reading the |api-metadata| from Nvim. |api-mapping| |
| - Clients should call |nvim_set_client_info()| after connecting, so users and |
| plugins can detect the client by handling the |ChanInfo| event. This avoids |
| the need for special variables or other client hints. |
| - Clients should handle |nvim_error_event| notifications, which will be sent |
| if an async request to nvim was rejected or caused an error. |
|
|
| Package Naming ~ |
|
|
| API client packages should NOT be named something ambiguous like "neovim" or |
| "python-client". Use "nvim" as a prefix/suffix to some other identifier |
| following ecosystem conventions. |
|
|
| For example, Python packages tend to have "py" in the name, so "pynvim" is |
| a good name: it's idiomatic and unambiguous. If the package is named "neovim", |
| it confuses users, and complicates documentation and discussions. |
|
|
| Examples of API-client package names: |
| - ✅ OK: nvim-racket |
| - ✅ OK: pynvim |
| - ❌ NO: python-client |
| - ❌ NO: neovim_ |
|
|
| API client implementation guidelines ~ |
|
|
| - Separate the transport layer from the rest of the library. |rpc-connecting| |
| - Use a MessagePack library that implements at least version 5 of the |
| MessagePack spec, which supports the BIN and EXT types used by Nvim. |
| - Use a single-threaded event loop library/pattern. |
| - Use a fiber/coroutine library for the language being used for implementing |
| a client. These greatly simplify concurrency and allow the library to |
| expose a blocking API on top of a non-blocking event loop without the |
| complexity that comes with preemptive multitasking. |
| - Don't assume anything about the order of responses to RPC requests. |
| - Clients should expect requests, which must be handled immediately because |
| Nvim is blocked while waiting for the client response. |
| - Clients should expect notifications, but these can be handled "ASAP" (rather |
| than immediately) because they won't block Nvim. |
| - For C/C++ projects, consider libmpack instead of the msgpack.org library. |
| https://github.com/libmpack/libmpack/ |
| libmpack is small (no dependencies, can inline into your C/C++ project) and |
| efficient (no allocations). It also implements msgpack-RPC, the protocol |
| required by Nvim. |
| https://github.com/msgpack-rpc/msgpack-rpc |
|
|
|
|
| EXTERNAL UI *dev-ui* |
|
|
| External UIs should be aware of the |api-contract|. In particular, future |
| versions of Nvim may add new items to existing events. The API is strongly |
| backwards-compatible, but clients must not break if new (optional) fields are |
| added to existing events. |
|
|
| Standard Features ~ |
|
|
| External UIs are expected to implement these common features: |
|
|
| - Call |nvim_set_client_info()| after connecting, so users and plugins can |
| detect the UI by handling the |ChanInfo| event. This avoids the need for |
| special variables and UI-specific config files (gvimrc, macvimrc, …). |
| - Cursor style (shape, color) should conform to the 'guicursor' properties |
| delivered with the mode_info_set UI event. |
| - Send the ALT/META ("Option" on macOS) key as a |<M-| chord. |
| - Send the "super" key (Windows key, Apple key) as a |<D-| chord. |
| - Avoid mappings that conflict with the Nvim keymap-space; GUIs have many new |
| chords (<C-,> <C-Enter> <C-S-x> <D-x>) and patterns ("shift shift") that do |
| not potentially conflict with Nvim defaults, plugins, etc. |
| - Consider the "option_set" |ui-global| event as a hint for other GUI |
| behaviors. Various UI-related options ('guifont', 'ambiwidth', …) are |
| published in this event. See also "mouse_on", "mouse_off". |
| - UIs generally should NOT set |$NVIM_APPNAME| (unless explicitly requested by |
| the user). |
| - Support the text decorations/attributes given by |ui-event-hl_attr_define|. |
| The "url" attr should be presented as a clickable hyperlink. |
|
|
|
|
| vim:tw=78:ts=8:sw=4:et:ft=help:norl: |
|
|
