Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/voldikss/vim-floaterm
:computer: Terminal manager for (neo)vim
https://github.com/voldikss/vim-floaterm
floating-window neovim vim-terminal
Last synced: 28 days ago
JSON representation
:computer: Terminal manager for (neo)vim
- Host: GitHub
- URL: https://github.com/voldikss/vim-floaterm
- Owner: voldikss
- License: mit
- Created: 2019-08-04T01:39:56.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2024-04-08T00:22:53.000Z (7 months ago)
- Last Synced: 2024-09-29T06:02:07.102Z (about 1 month ago)
- Topics: floating-window, neovim, vim-terminal
- Language: Vim Script
- Homepage:
- Size: 636 KB
- Stars: 2,475
- Watchers: 19
- Forks: 78
- Open Issues: 61
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- my-awesome-github-stars - voldikss/vim-floaterm - :computer: Terminal manager for (neo)vim (Vim Script)
- jimsghstars - voldikss/vim-floaterm - :computer: Terminal manager for (neo)vim (Vim Script)
README
Use (neo)vim terminal in the floating/popup window.
[](https://github.com/voldikss/vim-floaterm/actions?query=workflow%3ACI) [](https://github.com/voldikss/vim-floaterm/blob/master/LICENSE) [](https://github.com/voldikss/vim-floaterm/graphs/commit-activity)
- [Features](#features)
- [Requirements](#requirements)
- [Installation](#installation)
- [Get started](#get-started)
- [Commands](#commands)
- [Options](#options)
- [Keymaps](#keymaps)
- [Highlights](#highlights)
- [Autocmd](#autocmd)
- [Advanced Topics](#advanced-topics)
- [Use with command line tools](#use-with-command-line-tools)
- [Use with other plugins](#use-with-other-plugins)
- [How to define more wrappers](#how-to-define-more-wrappers)
- [How to write sources for fuzzy finder plugins](#how-to-write-sources-for-fuzzy-finder-plugins)
- [Contributing](#contributing)
- [FAQ](#faq)
- [Breaking changes](#breaking-changes)
- [Related projects](#related-projects)
- [Credits](#credits)
- [License](#license)
## Features
- Support neovim floatwin and vim8 popupwin
- Manage multiple terminal instances
- Customizable terminal window style
- Switch/preview floating terminal buffers using fuzzy-finder plugins such as
[denite.nvim](https://github.com/Shougo/denite.nvim) or
[fzf](https://github.com/junegunn/fzf), etc.
- Use with other external command-line tools(ranger, fzf, ripgrep etc.)
- Use as a custom task runner for [asynctasks.vim](https://github.com/skywind3000/asynctasks.vim)
or [asyncrun.vim](https://github.com/skywind3000/asyncrun.vim)
## Requirements
- Vim or neovim with `terminal` feature
## Installation
- packer.nvim
```lua
use 'voldikss/vim-floaterm'
```
- vim-plug
```vim
Plug 'voldikss/vim-floaterm'
```
- dein.nvim
```vim
call dein#add('voldikss/vim-floaterm')
```
## Get Started
Use `:FloatermNew` to open a terminal window, use `:FloatermToggle` to
hide/reopen that. The filetype of the terminal buffer is `floaterm`.
If you've opened multiple floaterm instances, they will be attached to a
double-circular-linkedlist. Then you can use `:FloatermNext` or
`: FloatermPrev` to switch between them.
**❗️Note**: Long-running jobs (e.g. `yarn watch`) inside the builtin terminal
would probably slowdown your operation. It's recommended to put them into the
external terminals.
### Commands
#### `:FloatermNew[!] [options] [cmd]` Open a floaterm window.
- If `!` is given, execute `cmd` in `$SHELL`. Try `:FloatermNew python` and
`: FloatermNew! python` to learn about the difference.
- If execute without `cmd`, open `$SHELL`.
- The `options` is formed as `--key[=value]`, it is used to specify local
attributes of a specific floaterm instance. Note that in order to input
space, you have to form it as `\` followed by space, and `\` must be typed
as `\\`
- `cwd` working directory that floaterm will be opened at. Accepts a
path, the literal `` which represents the project root directory,
the literal `` which specifies the directory of the active buffer,
or the literal `` which corresponds to the project root
directory of the active buffer.
- `name` name of the floaterm
- `silent` If `--silent` is given, spawn a floaterm but not open the window,
you may toggle it afterwards
- `disposable` If `--disposable` is given, the floaterm will be destroyed
once it is hidden.
- `title` see `g:floaterm_title`
- `width` see `g:floaterm_width`
- `height` see `g:floaterm_height`
- `opener` see `g:floaterm_opener`
- `wintype` see `g:floaterm_wintype`
- `position` see `g:floaterm_position`
- `autoclose` see `g:floaterm_autoclose`
- `borderchars` see `g:floaterm_borderchars`
- `titleposition` see `g:floaterm_titleposition`
- This command basically shares the consistent behaviors with the builtin `:terminal`:
- The special characters(`:help cmdline-special`) such as `%` and ``
will be auto-expanded, to get standalone characters, use `\` followed by
the corresponding character(e.g., `\%`).
- Note that ``(i.e., `|`) will be seen as an argument of the command,
therefore it can not be followed by another Vim command.
- If execute this command with a range, i.e., `'<,'>:FloatermNew ...`, the
selected lines will be sent to the created floaterm. For example, see
[python repl use case](#python) below.
- Use `` to get completion.
For example, the command
```vim
:FloatermNew --height=0.6 --width=0.4 --wintype=float --name=floaterm1 --position=topleft --autoclose=2 ranger --cmd="cd ~"
```
will open a new floating/popup floaterm instance named `floaterm1` running
`ranger --cmd="cd ~"` in the `topleft` corner of the main window.
The following command allows you to compile and run your C code in the floaterm window:
```vim
:FloatermNew --autoclose=0 gcc % -o %< && ./%<
```
#### `:FloatermPrev` Switch to the previous floaterm instance
#### `:FloatermNext` Switch to the next floaterm instance
#### `:FloatermFirst` Switch to the first floaterm instance
#### `:FloatermLast` Switch to the last floaterm instance
#### `:FloatermUpdate [options]` Update floaterm window attributes(`height`, `width`, etc.).
- The `options` is the same as in `:FloatermNew` (except `--silent`).
- Use `` to get completion.
#### `:[N]FloatermToggle[!] [floaterm_name]` Open or hide the floaterm window.
- If `N` is given, toggle the floaterm whose buffer number is `N`
- If `floaterm_name` is given, toggle the floaterm instance whose `name`
attribute is `floaterm_name`. Otherwise create a new floaterm named
`floaterm_name`.
- Use `` to get completion.
- If `!` is given, toggle all floaterms (`:FloatermHide!` or `: FloatermShow!`)
#### `:[N]FloatermShow[!] [floaterm_name]` Show the current floaterm window.
- If `N` is given, show the floaterm whose buffer number is `N`
- If `floaterm_name` is given, show the floaterm named `floaterm_name`.
- If `!` is given, show all floaterms (If multiple floaterms have the same
position attribute, only one of them will be show)
#### `:[N]FloatermHide[!] [floaterm_name]` Hide the current floaterms window.
- If `N` is given, hide the floaterm whose buffer number is `N`
- If `floaterm_name` is given, show the floaterm named `floaterm_name`.
- If `!` is given, hide all floaterms
#### `:[N]FloatermKill[!] [floaterm_name]` Kill the current floaterm instance
- If `N` is given, kill the floaterm whose buffer number is `N`
- If `floaterm_name` is given, kill the floaterm instance named `floaterm_name`.
- If `!` is given, kill all floaterms
#### `:FloatermSend[!] [--name=floaterm_name] [cmd]` Send command to a job in floaterm.
- If `--name=floaterm_name` is given, send lines to the floaterm instance
whose `name` is `floaterm_name`. Otherwise use the current floaterm.
- If `cmd` is given, it will be sent to floaterm and selected lines will be ignored.
- This command can also be used with a range, i.e., `'<,'>:FloatermSend [--name=floaterm_name]`
to send selected lines to a floaterm.
- If `cmd` is given, the selected lines will be ignored.
- If use this command with a `!`, i.e., `'<,'>:FloatermSend! [--name=floaterm_name]`
the common white spaces in the beginning of lines
will be trimmed while the relative indent between lines will still be
kept.
- Use `` to get completion.
- Examples
```vim
:FloatermSend " Send current line to the current floaterm (execute the line in the terminal)
:FloatermSend --name=ft1 " Send current line to the floaterm named ft1
:FloatermSend ls -la " Send `ls -la` to the current floaterm
:FloatermSend --name=ft1 ls -la " Send `ls -la` to the floaterm named ft1
:23FloatermSend ... " Send the line 23 to floaterm
:1,23FloatermSend ... " Send lines between line 1 and line 23 to floaterm
:'<,'>FloatermSend ... " Send lines selected to floaterm(visual block selection are supported)
:%FloatermSend ... " Send the whole buffer to floaterm
```
### Options
#### **`g:floaterm_shell`**
Type `String`. Default: `&shell`
#### **`g:floaterm_title`**
Type `String`. Show floaterm info(e.g., `'floaterm: 1/3'` implies there are 3
floaterms in total and the current is the first one) at the top left corner of
floaterm window.
Default: `'floaterm: $1/$2'`(`$1` and `$2` will be substituted by 'the index of
the current floaterm' and 'the count of all floaterms' respectively)
Example: `'floaterm($1|$2)'`
#### **`g:floaterm_wintype`**
Type `String`. `'float'`(nvim's floating or vim's popup) by default. Set it to
`'split'` or `'vsplit'` if you don't want to use floating or popup window.
#### **`g:floaterm_width`**
Type `Number` (number of columns) or `Float` (between 0 and 1). If `Float`,
the width is relative to `&columns`.
Default: `0.6`
#### **`g:floaterm_height`**
Type `Number` (number of lines) or `Float` (between 0 and 1). If `Float`, the
height is relative to `&lines`.
Default: `0.6`
#### **`g:floaterm_position`**
Type `String`. The position of the floating window. Available values:
- If `wintype` is `split`/`vsplit`: `'leftabove'`, `'aboveleft'`,
`'rightbelow'`, `'belowright'`, `'topleft'`, `'botright'`. Default:
`'botright'`.
It's recommended to have a look at those options meanings, e.g. `:help :leftabove`.
- If `wintype` is `float`: `'top'`, `'bottom'`, `'left'`, `'right'`,
`'topleft'`, `'topright'`, `'bottomleft'`, `'bottomright'`, `'center'`,
`'auto'(at the cursor place)`. Default: `'center'`
In addition, there is another option `'random'` which allows to pick a random
position from above when (re)opening a floaterm window.
#### **`g:floaterm_borderchars`**
Type `String`. 8 characters of the floating window border (top, right, bottom,
left, topleft, topright, botright, botleft).
Default: `─│─│┌┐┘└`
#### **`g:floaterm_rootmarkers`**
Type `List` of `String`. Markers used to detect the project root directory for `--cwd=`
or `--cwd=`.
Default: `['.project', '.git', '.hg', '.svn', '.root']`
#### **`g:floaterm_giteditor`**
Type `Boolean`. Whether to override `$GIT_EDITOR` in floaterm terminals so git commands can
open open an editor in the same neovim instance. See [git](#git) for details.
This flag also overrides `$HGEDITOR` for Mercurial.
Default: `v:true`
#### **`g:floaterm_opener`**
Type `String`. Command used for opening a file in the outside nvim from within `:terminal`.
Available: `'edit'`, `'split'`, `'vsplit'`, `'tabe'`, `'drop'` or
[user-defined commands](https://github.com/voldikss/vim-floaterm/issues/259)
Default: `'split'`
#### **`g:floaterm_autoclose`**
Type `Number`. Whether to close floaterm window once the job gets finished.
- `0`: Always do NOT close floaterm window
- `1`: Close window if the job exits normally, otherwise stay it with messages
like `[Process exited 101]`
- `2`: Always close floaterm window
Default: `1`.
#### **`g:floaterm_autohide`**
Type `Number`. Whether to hide previous floaterms before switching to or
opening a another one.
- `0`: Always do NOT hide previous floaterm windows
- `1`: Only hide those whose position (`b:floaterm_position`) is identical to
that of the floaterm which will be opened
- `2`: Always hide them
Default: `1`.
#### **`g:floaterm_autoinsert`**
Type `Boolean`. Whether to enter Terminal-mode after opening a floaterm.
Default: `v:true`
#### **`g:floaterm_titleposition`**
Type `String`. The position of the floaterm title.
Available: `'left'`, `'center'`, `'right'`.
Default: `'left'`
### Keymaps
This plugin doesn't supply any default mappings. Here are the configuration examples.
```vim
" Configuration example
let g:floaterm_keymap_new = ''
let g:floaterm_keymap_prev = ''
let g:floaterm_keymap_next = ''
let g:floaterm_keymap_toggle = ''
```
You can also use other keys as shown below:
```vim
let g:floaterm_keymap_new = 'ft'
```
All options for the mappings are listed below:
- `g:floaterm_keymap_new`
- `g:floaterm_keymap_prev`
- `g:floaterm_keymap_next`
- `g:floaterm_keymap_first`
- `g:floaterm_keymap_last`
- `g:floaterm_keymap_hide`
- `g:floaterm_keymap_show`
- `g:floaterm_keymap_kill`
- `g:floaterm_keymap_toggle`
Note that the key mappings are set from the [plugin/floaterm.vim](./plugin/floaterm.vim),
so if you are using on-demand loading feature provided by some plugin-managers,
the keymap above won't take effect(`:help load-plugins`). Then you have to
define the key bindings by yourself. For example,
```vim
nnoremap :FloatermNew
tnoremap :FloatermNew
nnoremap :FloatermPrev
tnoremap :FloatermPrev
nnoremap :FloatermNext
tnoremap :FloatermNext
nnoremap :FloatermToggle
tnoremap :FloatermToggle
```
### Highlights
There are two `highlight-groups` to specify the color of floaterm (also the
border color if `g: floaterm_wintype` is `'float'`) window.
To customize, use `hi` command together with the colors you prefer.
```vim
" Configuration example
" Set floaterm window's background to black
hi Floaterm guibg=black
" Set floating window border line color to cyan, and background to orange
hi FloatermBorder guibg=orange guifg=cyan
```
Demo
Besides, there is a neovim only highlight group which can be used to configure
no-current-focused window(`:help NormalNC`).
```vim
" Configuration example
" Set floaterm window foreground to gray once the cursor moves out from it
hi FloatermNC guifg=gray
```
Demo
### Autocmd
```vim
autocmd User FloatermOpen " triggered after opening a new/existed floaterm
```
## Advanced Topics
### Use with command line tools
The following cases should work both in Vim and NeoVim unless otherwise
specifically noted.
#### floaterm
Normally if you run `vim/nvim somefile.txt` within the builtin terminal, you
would get another nvim/vim instance running in the subprocess.
[Floaterm](https://github.com/voldikss/vim-floaterm/tree/master/bin), which is
a builtin script in this plugin, allows you to open files from within `: terminal`
without starting a nested nvim. To achieve that, just literally replace
`vim/nvim` with `floaterm`, e.g. `floaterm somefile.txt`
P.S.
- [#208](https://github.com/voldikss/vim-floaterm/issues/208#issuecomment-747829311)
describes how to use `gf` in the floating terminal window.
- `floaterm` is too long to type? set alias in your `bashrc`, e.g. `alias f=floaterm`
- For configurable open action, refer to [g:floaterm_opener](#gfloaterm_opener)
Demo
#### [git](https://git-scm.com/)
Execute `git commit` in the terminal window without starting a nested vim/nvim.
Refer to [g:floaterm_giteditor](#gfloaterm_giteditor) to disable this behavior.
Refer to [g:floaterm_opener](#gfloaterm_opener) for configurable open action
Demo
#### [fzf](https://github.com/junegunn/fzf)
This plugin has implemented a [wrapper](./autoload/floaterm/wrapper/fzf.vim)
for `fzf` command. So it can be used as a tiny fzf plugin.
Try `:FloatermNew fzf` or even wrap this to a new command like this:
```vim
command! FZF FloatermNew fzf
```
Demo
#### [ripgrep](https://github.com/BurntSushi/ripgrep)
_Requirements_:
- [fzf](https://github.com/junegunn/fzf)
- [vim-ripgrep](https://github.com/jremmen/vim-ripgrep)
This plugin has implemented a [wrapper](./autoload/floaterm/wrapper/rg.vim)
for `rg` command.
Try `:FloatermNew rg` or create yourself a new command like this:
```vim
command! Rg FloatermNew --width=0.8 --height=0.8 rg
```
or map via `.vimrc`
```vim
" Hotkey: \ + rg
nmap rg :Rg
```
Demo
You can use Alt-A to select all files and Alt-D to deselect them.
Use Ctrl-/ to toggle preview.
#### [broot](https://github.com/Canop/broot)
This plugin has implemented a [wrapper](./autoload/floaterm/wrapper/broot.vim) for `broot`.
Try `:FloatermNew broot` or create yourself a new command like this:
```vim
command! Broot FloatermNew --width=0.8 --height=0.8 broot
```
Demo
#### [fff](https://github.com/dylanaraps/fff)
There is also an [fff wrapper](./autoload/floaterm/wrapper/fff.vim)
Try `:FloatermNew fff` or define a new command:
```vim
command! FFF FloatermNew fff
```
Demo
#### [nnn](https://github.com/jarun/nnn)
There is also an [nnn wrapper](./autoload/floaterm/wrapper/nnn.vim)
Try `:FloatermNew nnn` or define a new command:
```vim
command! NNN FloatermNew nnn
```
Demo
#### [xplr](https://github.com/sayanarijit/xplr)
There is also an [xplr wrapper](./autoload/floaterm/wrapper/xplr.vim)
Try `:FloatermNew xplr` or define a new command:
```vim
command! XPLR FloatermNew xplr
```
Demo
#### [lf](https://github.com/gokcehan/lf)
There is also an [lf wrapper](./autoload/floaterm/wrapper/lf.vim).
It is recommened to use [lf.vim](https://github.com/ptzz/lf.vim) which is an lf wrapper with more features (Overriding netrw, Lfcd, etc.).
Try `:FloatermNew lf` or define a new command:
```vim
command! LF FloatermNew lf
```
Demo
#### [ranger](https://github.com/ranger/ranger)
This plugin can also be a handy ranger plugin since it also has a [ranger wrapper](./autoload/floaterm/wrapper/ranger.vim)
Try `:FloatermNew ranger` or define a new command:
```vim
command! Ranger FloatermNew ranger
```
Demo
#### [joshuto](https://github.com/kamiyaa/joshuto)
This plugin can also be a handy joshuto plugin since it also has a [joshuto wrapper](./autoload/floaterm/wrapper/joshuto.vim)
Try `:FloatermNew joshuto` or define a new command:
```vim
command! Joshuto FloatermNew joshuto
```
#### [vifm](https://github.com/vifm/vifm)
There is also a [vifm wrapper](./autoload/floaterm/wrapper/vifm.vim)
Try `:FloatermNew vifm` or define a new command:
```vim
command! Vifm FloatermNew vifm
```
Demo
#### [yazi](https://github.com/sxyazi/yazi)
There is also a [yazi wrapper](./autoload/floaterm/wrapper/yazi.vim)
Try `:FloatermNew yazi` or define a new command:
```vim
command! Yazi FloatermNew yazi
```
#### [lazygit](https://github.com/jesseduffield/lazygit)
Furthermore, you can also use other command-line programs, such as lazygit, htop, ncdu, etc.
Use `lazygit` for instance:
Demo
#### [python](https://www.python.org/)
Use `:FloatermNew python` to open a python shell. After that you can use
`: FloatermSend` to send lines to the Python interactive shell.
Or you can just select lines and execute `:'<,'>FloatermNew --wintype=split python`, then the
selected lines will be sent and executed once a python repl floaterm window is
opened.
This can also work for other languages which have interactive shells, such as lua, node, etc.
Demo
### Use with other plugins
#### [vim-clap](https://github.com/liuchengxu/vim-clap)
Use vim-clap to switch/preview floating terminal buffers.
Install [clap-floaterm](https://github.com/voldikss/clap-floaterm) and try `:Clap floaterm`
Demo
#### [denite.nvim](https://github.com/Shougo/denite.nvim)
Use denite to switch/preview/open floating terminal buffers.
Install [denite-floaterm](https://github.com/delphinus/denite-floaterm) and try `:Denial floaterm`
Demo
#### [coc.nvim](https://github.com/neoclide/coc.nvim)
Use CocList to switch/preview/open floating terminal buffers.
Install [coc-floaterm](https://github.com/voldikss/coc-floaterm) and try `:CocList floaterm`
Demo
#### [fzf](https://github.com/junegunn/fzf)
Install [fzf-floaterm](https://github.com/voldikss/fzf-floaterm) and try `:Floaterms`
#### [LeaderF](https://github.com/Yggdroot/LeaderF)
Install [LeaderF-floaterm](https://github.com/voldikss/LeaderF-floaterm) and try `:Leaderf floaterm`
#### [asynctasks.vim](https://github.com/skywind3000/asynctasks.vim) | [asyncrun.vim](https://github.com/skywind3000/asyncrun.vim)
This plugin can be a runner for asynctasks.vim or asyncrun.vim. See
[asyncrun.extra](https://github.com/skywind3000/asyncrun.extra) for the
installation and usage.
Demo
### How to define more wrappers
The wrapper script must be located in `autoload/floaterm/wrapper/` directory,
e.g., `autoload/floaterm/wrapper/fzf.vim`.
There are two ways for a command to be spawned:
- To be executed after spawning `$SHELL`. Here is the old implementation of
[fzf wrapper](./autoload/floaterm/wrapper/fzf.vim)
```vim
function! floaterm#wrapper#fzf#(cmd, jobopts, config) abort
return [v:true, 'floaterm $(fzf)']
endfunction
```
The code above returns a list. `floaterm $(fzf)` is the command to be
executed. `v:true` means the command will be executed after the `&shell`
startup.
- To be executed through `termopen()`/`term_start()` function, in that case, a
callback option can be provided. See [fzf wrapper](./autoload/floaterm/wrapper/fzf.vim)
```vim
function! floaterm#wrapper#fzf#(cmd, jobopts, config) abort
let s:fzf_tmpfile = tempname()
let cmd = a:cmd . ' > ' . s:fzf_tmpfile
let a:jobopts.on_exit = funcref('s:fzf_callback')
return [v:false, cmd]
endfunction
function! s:fzf_callback(...) abort
if filereadable(s:fzf_tmpfile)
let filenames = readfile(s:fzf_tmpfile)
if !empty(filenames)
if has('nvim')
call floaterm#window#hide(bufnr('%'))
endif
let locations = []
for filename in filenames
let dict = {'filename': fnamemodify(filename, ':p')}
call add(locations, dict)
endfor
call floaterm#util#open(locations)
endif
endif
endfunction
```
In the example above, after executing `:FloatermNew fzf`, function
`floaterm#wrapper#fzf#` will return
```vim
[v:false, 'fzf > /tmp/atmpfilename'].
```
Here `v:false` means `cmd`
```vim
fzf > /tmp/atmpfilename
```
will be passed through `termopen()`(neovim) or `term_start()`(vim). As the
result, an fzf interactive will be opened in a floaterm window.
When user picks a file using `ENTER`, fzf exits and the filepath will be
written in `/tmp/atmpfilename` and `s:fzf_callback()` will be invoked to
open the file. Note that the function `s: fzf_callback()` is registered by
```vim
let a:jobopts.on_exit = funcref('s:fzf_callback')
```
The variable `a:jobopts` in the above code will be eventually passed to
`termopen()`(neovim) or `term_start()`(vim). For more info, see
`:help jobstart-options`(neovim) or `:help job-options`(vim)
### How to write sources for fuzzy finder plugins
Function `floaterm#buflist#gather()` returns a list contains all the floaterm buffers.
Function `floaterm#terminal#open_existing({bufnr})` opens the floaterm whose buffer number is `{bufnr}`.
For reference, see [floaterm source for LeaderF](https://github.com/voldikss/LeaderF-floaterm/blob/master/autoload/lf_floaterm.vim).
## Contributing
- Improve the documentation
- Help resolve issues labeled as [help wanted](https://github.com/voldikss/vim-floaterm/issues?q=is%3Aissue+label%3A%22help+wanted%22)
## FAQ
https://github.com/voldikss/vim-floaterm/issues?q=label%3AFAQ
## Breaking Changes
https://github.com/voldikss/vim-floaterm/issues?q=label%3A%22breaking+change%22
## Related projects
- [vim-floaterm-repl](https://github.com/windwp/vim-floaterm-repl)
- [coc-floaterm](https://github.com/voldikss/coc-floaterm)
- [fzf-floaterm](https://github.com/voldikss/fzf-floaterm)
- [popc-floaterm](https://github.com/yehuohan/popc-floaterm)
- [LeaderF-floaterm](https://github.com/voldikss/LeaderF-floaterm)
## Credits
- [Vim](https://github.com/vim/vim/) and [Neovim](https://github.com/neovim/neovim/) the editor God
- [vim-terminal-help](https://github.com/skywind3000/vim-terminal-help/blob/master/tools/utils/drop)
- [edita.vim](https://github.com/lambdalisue/edita.vim)
## License
MIT