Hi, thanks for making this plugin! It is awesome!

I like the start_in_insert = true feature a lot. However, sometimes (for example, when I am looking at output of a lot of tests), I use C-\ C-n to exit insert mode and scroll up, and toggle to get to the test file in question. However, if I want to refer to the test output again, now when I toggle back to the terminal it enters insert mode and goes back to the terminal input and I have to scroll back again.

It would be nice if the plugin can track whether the user is in insert mode or not and choose not to enter insert mode if a user has C-\ C-n in the terminal.

One way I think this could be achieved is by using autocommands that work only in the terminal. Thoughts?

Thanks for the great plugin.
I have a question is there a way to have a command that toggles view with all the terminals that were created?
For example:
I created terminal with CTRl-\ than I created another terminal with a :ToggleTerm 2
which leads to this view

Than I want to hide all terminals (:ToggleTerm all alike) and continue to work on editing files and after some time to toggle it again and have same view as before - 2 terminals bellow editing window (cause now CTRL -\ will only toggle one of the terminals, not all of them).
This behaviour is similar to tmux prefix-z command which toggles maximize one pane. Or something like toggle terminal in heavy IDE-s like vscode, idea etc.

If i run an nodejs server api in terminal, does can it persist that process ?

I'm pretty new to use using vim/neovim and still finding my way around installing plugins/editing my config.

It seems like there's no consistent naming scheme for neovim/vim plugins, so I had to try a couple plugin names before the plugin installed successfully.

Suggestion:
add an install section with directions like

if you're using Packer as your plugin manager install this plugin using:

        use "akinsho/nvim-toggleterm.lua"

I'd be happy to contribute a PR if this is something worthwhile.

If you call :bdelete! on a toggleterm buffer, you will have Failed to close window: win id - does not exist error.

Steps to reproduce :

1. open horizontal term
2. change to non-terminal buffer
3. :q
4. open horizontal term
5. use exit command
6. open horizontal term <-- bug happens

Setting persist_size = false seems to fix the problem(but idk why).

At first, I think this is problem with neovim, but telescope work fine.

Steps:

• open ToggleTerm
• change window position with Ctrl-W + L
• close term with :ToggleTerm
• open term with :ToggleTerm
  --> wrong size (full width)

That could be great to have a list of opens terminal and to choose between them through a picker like Telescope for example.

Locally I've removed the display of numbers from the terminal buffer since I don't think terminal's need that. The actually aren't visible in vim 8+'s terminal. I thought it might add this as a configurable option so other users can have it. I'll implement this in the coming weeks but if anyone has an opinion of why it shouldn't be the default please post here

Is there a way to toggle the terminal only when in normal mode, using the provided open_mapping settings? Or can this only be done using the manual way? I'm new to neovim (and lua), so apologies in advance if this is a dumb question.

This is what I'd like:

In normal mode ` will toggle a terminal and in insert I'd have it mapped to Ctrl + ` .

PS:I tried a different mapping as an experimentation, but I couldn't get it to work. It was: <leader> o t and I used [[<leader>ot]] as the value of open_mappings. Am I formatting it wrong?

This wasn't the case with vimfloaterm or Fterm.nvim, anyway to fix this?

Config:

require'toggleterm'.setup{
  size = 20,
  open_mapping = [[<c-space>]],
  shade_filetypes = {},
  shade_terminals = true,
  -- shading_factor = '<number>' -- the degree by which to darken to terminal colour, default: 1 for dark backgrounds, 3 for light
  start_in_insert = true,
  persist_size = true,
  -- direction = 'vertical' | 'horizontal',
}

After first mapping:

After second mapping:

Can't remember what was the previous time I updated but this started happening just after I updated just now.

Question

How could one go on about integrating this plugin with programs such as joshuto, nnn, lf, and ranger?

Acknowledgments

I know that this is already somewhat possible as you can open a terminal that runs the program on startup and then just open the file from there, however, I have found that this does not work.

What is expected is that when you open a file with your terminal file manager, it opens a new buffer with the selected file, however, what actually happens is that the terminal uses a new instance of neovim within itself and edits the file there.

Example:

Goal

Create a template that can be used to easily integrate terminal file managers with neovim using this plugin.

Is there a way for me to toggle a terminal, and then want to toggle another terminal, but in a different direction/orientation? It looks like right now, the direction is just hard-coded into the setup.

Currently, the terminal size is hardcoded in plugin/toggleterm.vim and plugin/toggleterm.vim to 12 rows in the call to exec().

A variable like g:toggleterm_size could easily be created and allow the user to set their preference by feeding it to toggleterm.exec

Something similar could be done to the split direction to allow vsplit, although it'd require a bit more work.

Is there a way to send the line number with TermExec? I know it's available to vim via line('.'), but that doesn't appear to be one of the things that the expand command expands.

Context: I'm trying to use the :TermExec command to execute ruby specs. To run all the specs in a file, I have this key binding:

vim.api.nvim_set_keymap('n', '<Leader>q', "<cmd>1TermExec cmd='bundle exec rspec %'<CR>", {})

That works great for executing entire files of specs. But Rspec has a feature that allows executing only the spec on a single line. To do this, I can append the line to the end of the filename, like so: rspec my_spec.rb:23. Based on the expand documentation, I thought that the following might work, but I guess my spec buffers aren't sourced script files: nvim says no line number to use for "<sflnum>".

vim.api.nvim_set_keymap('n', '<Leader>q', "<cmd>1TermExec cmd='bundle exec rspec %:<sflnum>'<CR>", {})

It'll be really helpful to have the help documentation (help-tags? Don't know how is it call) for Neovim. Right now I've to come to github and search if what i've want to do is possible. (awesome plugin by the way!)

I could help if you need a hand!

Following up from #62 (comment)

Summary: when I was using require('toggleterm').exec(...) to run something with this configuration, the floating terminal would not auto open

@akinsho said:

Seems term exec doesn't open a float like it does for splits since it doesn't really seem to take the direction into consideration, maybe.

It produces a very low-contrast terminal that's very hard to see. A better approach might be to darken the terminal if the user uses a light theme instead.

I keep getting this error when I toggle the terminal:

Here is my mapping in my init.vim:

Please let me know if I am doing something wrong. Thanks!

I'm using neovim (v0.5.0) on windows.
My shell is set to pwsh.exe. Starting a default terminal (so not using the plugin) works via the command :terminal

When using the plugin I get a quick error message before the terminal is closed:

at System.Management.Automation.Remoting.OutOfProcessUtils.ProcessData(String data, DataProcessingDeleegates callback)
at System.Management.Automation.Remoting.Server.OutOfProcessMediatorBase.ProcessingThreadStart(Object state)

I didn't change the default config a lot:

require("toggleterm").setup{
  function(term)
    if term.direction == "horizontal" then
      return 15
    elseif term.direction == "vertical" then
      return vim.o.columns * 0.4
    end
  end,
  open_mapping = [[<Leader>t]],
  hide_numbers = true, 
  shade_filetypes = {},
  shade_terminals = true,
  shading_factor = '1', 
  start_in_insert = true,
  insert_mappings = true, 
  persist_size = true,
  direction = 'float', 
  close_on_exit = true, 
  shell = "pwsh.exe", 
  float_opts = {
    border = 'single', 
    width = 80,
    height = 100,
    winblend = 3,
    highlights = {
      border = "Normal",
      background = "Normal",
    }
  }
}

Like open term from directory/git root/project root of current file?

How can we exit the insert mode when in terminal?

In my experience so far, the :ToggleTerm command is really very slow.
It takes about 3-4 seconds to spawn the terminal in a split.
I believe making the process asynchronous would help a bit.

Is there a way to send commands to terminal without opening ?
Thank you

When I toggle the terminal I get this error message:

Failed to close window: win id - does not exist

my config:

require("toggleterm").setup {
size = 20,
open_mapping = [[]],
hide_numbers = true,
shade_filetypes = {},
shade_terminals = true,
shading_factor = 1,
start_in_insert = true,
insert_mappings = true,
persist_size = true,
direction = "horizontal",
close_on_exit = true,
shell = vim.o.shell,
float_opts = {
border = "single",
winblend = 3,
highlights = {
border = "Normal",
background = "Normal",
},
},
}

Problem description

There's a significant delay when navigating with j/k compared to using arrow-keys.

Demo

Thanks for the fantastic extension, I assume this is a bug.

1. ToggleTerm to make a new terminal
2. Enter normal mode (jk on my setup)
3. Open custom terminal (lazygit)
4. press q to quit lazygit custom terminal
5. Now you are back in the original terminal, ToggleTerm = "Couldn't find a terminal to close" error, the terminal must be exited manually with exit

in init.vim

" toggle terminal
nnoremap <silent><leader>t :ToggleTerm<CR>

lua <<EOF
require("toggleterm").setup{ size = 80, direction = 'vertical' }
local Terminal  = require('toggleterm.terminal').Terminal
local lazygit = Terminal:new({ cmd = "lazygit", hidden = true, direction = "float" })
function _lazygit_toggle()
  lazygit:toggle()
end

vim.api.nvim_set_keymap("n", "<leader>g", "<cmd>lua _lazygit_toggle()<CR>", {noremap = true, silent = true})
EOF

I tried your other lazygit setup, and got the same results, apart from the terminal needed confirmation to close. Is this needed for lazygit to work well?:

local lazygit = Terminal:new({
  cmd = "lazygit",
  dir = "git_dir",
  direction = "float",
  float_opts = {
    border = "double",
  },
  -- function to run on opening the terminal
  on_open = function(term)
    vim.cmd("startinsert!")
    vim.api.nvim_buf_set_keymap(term.bufnr, "n", "q", "<cmd>close<CR>", {noremap = true, silent = true})
  end,
  -- function to run on closing the terminal
  on_close = function(term)
    vim.cmd("Closing terminal")
  end,
})

I don't really understand how Lua works, so please forgive any obvious mistake I have made. I am happy to just have one terminal toggling and lazygit in a floating window, would be perfect :)

I tried this autocmd

autocmd TermOpen * startinsert
autocmd TermLeave * stopinsert

But It only enters insert mode on the first opening, when I toggle down and toggle up again, it starts on normal mode

https://asciinema.org/a/AOjS5IuzDJE4sk8KSQcE183TP

The cursor still looks like a block when in the terminal in insert mode and it can be a bit confusing.

Is this intended or is there a way to have the default behaviour?

would you be open to making the insert mode mapping configurable? https://github.com/akinsho/nvim-toggleterm.lua/blob/master/lua/toggleterm.lua#L264

I basically never want to make insert mode keybinds

Is there a way you could open the terminal buffer in a separate buffer instead of a split?

Autoclose when we exit the terminal inside the buffer. if no terminal is running the buffer then it should delete the buffer and close the window

Firstly, thank you very much @akinsho and team for these great NeoVim plugins!!!
I really appreciate it

This regards toggleTerm & bufferline

I can't find a more appropriate place to ask, but what would be the best way of making a terminal buffer that can appear in the buffer line but still be toggled?

:Terminal works well, but it's not a ToggleTerm, thus can't be hidden

:ToggleTerm direction=window works well, but doesn't appear in the bufferline

I'm not sure how best to approach this, thanks in advance for the help!

How to toggle back to the neovim editor from the float/vertical terminal. At the moment, I tried ctrl+w+ctrl+w, but it is not working? Any solutions?

First off, thanks for the great plugin!

I was excited to test the new float term functionality, but am getting an error. It's entirely possible I'm doing something wrong in my configuration. The documentation is not entirely clear.

I am setting direction = 'float', which by looking at the code seems to be the way to opt in, although in the read me documentation float was not presented as an option (although float_opts is). I set up float_opts with some values and get this error when invoking the terminal:

I tried removing the border key, and removing float_opts entirely, but no dice.

Any help would be appreciated.

Thanks again!

let mapleader = "\<Space>"

" toggle line numbers                          < example, does not trigger in insert mode
nnoremap <silent><leader>n :set invnumber<CR>

lua <<EOF
require("toggleterm").setup{ size = 80, direction = 'vertical', open_mapping = [[<leader>t]] }
local Terminal  = require('toggleterm.terminal').Terminal
local lazygit = Terminal:new({ cmd = "lazygit", hidden = true, direction = "float" })

function _lazygit_toggle()
  lazygit:toggle()
end

vim.api.nvim_set_keymap("n", "<leader>g", "<cmd>lua _lazygit_toggle()<CR>", {noremap = true, silent = true})
EOF

When using space as the leader key now there is a delay after pressing every space in insert mode. The terminal can be toggled from insert mode, I assume this is an error as the leader key is expected to work from normal mode? I am not an expert in this, but that is how it works with all my other mappings.

With the above setup, whenever pressing space in insert mode Neovim acts as if there are potentially more keys in the sequence expected. It is like when you have jk as escape and press j then there is a delay while it waits to see if you press k.

I have installed the latest nightly (Linux appimage):

nvim --version
NVIM v0.5.0-dev+1358-g192ea01ed

When i open Toggle terminal, I have this issue

Can you give a solution for this?

First of all, excellent plugin and thanks a million for putting effort in this (and other) plugins. I'm using nvim-toggleterm daily in my workflow with a few custom functions for my specific preferences.

One thing I haven't been able to figure out yet is how to navigate to a terminal window based on it's count number, regardless if the terminal window is already open (but not focused) or not opened (anymore).

• If the terminal window hasn't been opened yet or if I have previously closed the terminal window (but left it running in the background), i'm fine using :toggle to open the terminal window (again). However, if I focus on a non-terminal window and use :toggle to refer to the specific terminal window to focus on, it closes the already open terminal window and errors out with Failed to close window: win id - [0-9]{1,4} does not exist (mind the in-place regex).

I can of course move to the terminal window using, for instance, 2wincmd w, or whatever number the window got assigned. It however requires me to look at the statusline to find out the window number to determine which one i'll have to move to, which obviously is less optimal than it could be ;-).

Is there a way to refocus on an already open terminal window by referring to it's number (set using count = [0-9]+) making use of an nvim-toggleterm function or similar ? This way I can hook a keymapping to it, preferably the same keymapping I already use to toggle it so I can keep using one keymapping per function.

For convenience, the nvim-toggleterm snippet i'm using with NVIM v0.5.0-dev+61aefaf29 on MacOS here below:

require('toggleterm').setup {
  close_on_exit = true,
  float_opts = {
    border = 'curved'
  },
  persist_size = false
}

local terminal_default_float = require('toggleterm.terminal').Terminal:new({
  count = 50,
  direction = 'float',
  on_open = function(term)
    vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<cr>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-k>', '<c-\\><c-n><cmd>close<cr><c-w><c-p>', { noremap = true })
    vim.wo.cursorcolumn = false
    vim.wo.cursorline = false
    vim.cmd('VimadeBufDisable')
    vim.cmd("startinsert!")
  end,
  on_close = function(term)
    vim.cmd("quit!")
  end
})

local terminal_horizontal_one = require('toggleterm.terminal').Terminal:new({
  count = 11,
  direction = 'horizontal',
  on_open = function(term)
    vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<cr>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-b>', '<c-\\><c-n><cmd>close<cr><c-w><c-p>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-k>', '<c-\\><c-n><c-w><c-p>', { noremap = true, silent = true })
    vim.wo.cursorcolumn = false
    vim.wo.cursorline = false
    vim.cmd('VimadeBufDisable')
    vim.cmd("startinsert!")
  end,
  on_close = function(term)
    vim.cmd("quit!")
  end
})

local terminal_horizontal_two = require('toggleterm.terminal').Terminal:new({
  count = 12,
  direction = 'horizontal',
  on_open = function(term)
    vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<cr>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-b>', '<c-\\><c-n><cmd>close<cr><c-w><c-p>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-k>', '<c-\\><c-n><c-w><c-p>', { noremap = true, silent = true })
    vim.wo.cursorcolumn = false
    vim.wo.cursorline = false
    vim.cmd('VimadeBufDisable')
    vim.cmd("startinsert!")
  end,
  on_close = function(term)
    vim.cmd("quit!")
  end
})

local terminal_horizontal_three = require('toggleterm.terminal').Terminal:new({
  count = 13,
  direction = 'horizontal',
  on_open = function(term)
    vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<cr>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-b>', '<c-\\><c-n><cmd>close<cr><c-w><c-p>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-k>', '<c-\\><c-n><c-w><c-p>', { noremap = true, silent = true })
    vim.wo.cursorcolumn = false
    vim.wo.cursorline = false
    vim.cmd('VimadeBufDisable')
    vim.cmd("startinsert!")
  end,
  on_close = function(term)
    vim.cmd("quit!")
  end
})

function _terminal_default_float_toggle()
  terminal_default_float:toggle()
end

function _terminal_horizontal_one_toggle()
  terminal_horizontal_one:toggle()
end

function _terminal_horizontal_two_toggle()
  terminal_horizontal_two:toggle()
end

function _terminal_horizontal_three_toggle()
  terminal_horizontal_three:toggle()
end

local terminal_tig = require('toggleterm.terminal').Terminal:new({
  cmd = 'tig',
  count = 60,
  direction = 'float',
  on_open = function(term)
    vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<cr>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-k>', '<c-\\><c-n><cmd>close<cr><c-w><c-p>', { noremap = true })
    vim.wo.cursorcolumn = false
    vim.wo.cursorline = false
    vim.cmd('VimadeBufDisable')
    vim.cmd("startinsert!")
  end,
  on_close = function(term)
    vim.cmd("quit!")
  end
})

local terminal_lazygit = require('toggleterm.terminal').Terminal:new({
  cmd = 'lazygit',
  count = 61,
  direction = 'float',
  on_open = function(term)
    vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<cr>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-k>', '<c-\\><c-n><cmd>close<cr><c-w><c-p>', { noremap = true })
    vim.wo.cursorcolumn = false
    vim.wo.cursorline = false
    vim.cmd('VimadeBufDisable')
    vim.cmd("startinsert!")
  end,
  on_close = function(term)
    vim.cmd("quit!")
  end
})

local terminal_k9s = require('toggleterm.terminal').Terminal:new({
  cmd = 'k9s',
  count = 62,
  direction = 'float',
  on_open = function(term)
    vim.api.nvim_buf_set_keymap(term.bufnr, 'n', 'q', '<cmd>close<cr>', { noremap = true, silent = true })
    vim.api.nvim_buf_set_keymap(term.bufnr, 't', '<c-k>', '<c-\\><c-n><cmd>close<cr><c-w><c-p>', { noremap = true })
    vim.wo.cursorcolumn = false
    vim.wo.cursorline = false
    vim.cmd('VimadeBufDisable')
    vim.cmd("startinsert!")
  end,
  on_close = function(term)
    vim.cmd("quit!")
  end
})

function _terminal_tig_toggle()
  terminal_tig:toggle()
end

function _terminal_lazygit_toggle()
  terminal_lazygit:toggle()
end

function _terminal_k9s_toggle()
  terminal_k9s:toggle()
end

lua _terminal_horizontal_one_toggle()
lua _terminal_horizontal_two_toggle()
lua _terminal_horizontal_three_toggle()
lua _terminal_default_float_toggle()
lua _terminal_k9s_toggle()
lua _terminal_lazygit_toggle()
lua _terminal_tig_toggle

i use the latest neovim and plugin,my config is below:

require"toggleterm".setup{
  size = 20,
  open_mapping = [[<c-A-\>]],
  shade_filetypes = {},
  shade_terminals = true,
  shading_factor = '<number>',
  start_in_insert = true,
  persist_size = true,
  direction = 'horizontal',
}

before i can use number and this keymap([c-a-]) use the same serial number term to run diffrent command in their respective term,but now it can't, every time it open a new term with clear info, then the command I ran is missing, it can't be reduced.
What can I do to achieve the previous effect?

I made a custom floating buffer and if I close the shell by doing exit, the buffer is taken off focus but is still hidden. When I toggle the custom floating terminal again, it shows the last session with a [Process exited 0] at the end of terminal. The expected behaviour should be to delete buffer on process exit.

Hello, I have been trying without success to manage mapping keys to toggling multiple terminals. I can manage to open the terminal by using the open_mapping keymap but when I am already in an open terminal and in terminal mode, I cannot do 2<C-> to open another terminal because it just writes the letter 2 into the terminal and then just closes it.

When I use the plugin for a floating lazygit window I want to be able to press esc to cancel a commit, etc instead of being put in normal mode (not really useful in lazygit). I tried adding

    on_open = function(term)
        vim.api.nvim_buf_set_keymap(term.bufnr, 'i', '<Esc>', '<NOP>', {noremap = true, silent = true})
    end

but it doesn't seem to work. Any ideas?

In can be nice to be able to switch direction of already opened terminal.
E.g: if you launch a server in a terminal, you would want to have it in float or window direction most of the time, but when it's debug time, it's nice to have it in vertical or horizontal

Right now I'm using vim-floaterm to spawn a terminal with lazygit like this:

And that's the only thing I use floaterm for. It's just to have a nice integration of git inside neovim. Then I use toggleterm to toggle a terminal easily in a more classical horizontal layout.

However I wonder if I can achieve what I do with floaterm with just using toggleterm, which has more options like also spawning windows in floating mode. But I haven't figured out how to set custom keybindings to specific layouts or terminals.

For example, to toggle the terminal I have <A-t> and for floaterm with the lazygit command I have <leader>gg , what I want to do is to set one specific keybind to toggle toggleterm in floating mode executing the lazygit command, and then my regular for the terminal in horizontal layout.

The problem I found is that the open_mappings option for toggling terminal is global, and it doesn't work for specific layouts with specific keybindings for those layouts. So if create a function to open toggleterm in floating mode and executing the lazygit command, then the toggle keybinding will only work for that specific terminal.

So the question is:

• Can I set an specific keybinding for different layouts/terminals ?
• If it's not possible, How difficult is it to implement ?

Is there. a way to pass the path of the current buffer (%) to the TermExec function like you can with the :terminal command?

As in #12, I'm trying to pass the current file name to TermExec.
However after the syntax update, TermExec cmd='a'.expand('%').'b' no longer works, it only considers a as the command.

E5108: Error executing lua ...ack/packer/opt/nvim-toggleterm.lua/lua/toggleterm/ui.lua:256: Vim:E444: Cannot close last window
This was thrown when I was trying to exit from a file buffer while a horizontal toggle term instance is opening
Expected behavior :wq on file buffer exit both file buffer and the horizontal toggle term.