Neovim compiler for building and running your code without having to configure anything.
- Why
- Supported languages
- Required system dependencies
- How to install
- Commands
- Basic usage
- Creating a solution (optional)
- Build automation utilities (optional)
- Quick start
- FAQ
Those familiar with Visual Studio IDE will remember how convenient it was to just press a button and having your program compiled and running. I wanted to bring that same user experience to Neovim.
Language | More info |
---|---|
asm x86-64 | |
c | |
c++ | |
c# | +info |
dart | +info |
elixir | +info |
f# | +info |
flutter | +info |
go | |
java | +info |
javascript | +info |
kotlin | +info |
lua | |
make | |
perl | |
python | +info |
r | |
ruby | |
rust | |
shell | +info |
swift | |
typescript | +info |
visual basic dotnet | +info |
zig | +info |
Some languages require you manually install their compilers in your machine, so compiler.nvim is able to call them. Please check here, as the packages will be different depending your operative system.
{ -- This plugin
"Zeioth/compiler.nvim",
cmd = {"CompilerOpen", "CompilerToggleResults", "CompilerRedo"},
dependencies = { "stevearc/overseer.nvim" },
opts = {},
},
{ -- The task runner we use
"stevearc/overseer.nvim",
commit = "68a2d344cea4a2e11acfb5690dc8ecd1a1ec0ce0",
cmd = { "CompilerOpen", "CompilerToggleResults", "CompilerRedo" },
opts = {
task_list = {
direction = "bottom",
min_height = 25,
max_height = 25,
default_detail = 1
},
},
},
Plug 'stevearc/overseer.nvim', {'commit': '68a2d344cea4a2e11acfb5690dc8ecd1a1ec0ce0'}
Plug 'Zeioth/compiler.nvim'
and then setup with:
require("compiler").setup()
-- Open compiler
vim.api.nvim_set_keymap('n', '<F6>', "<cmd>CompilerOpen<cr>", { noremap = true, silent = true })
-- Redo last selected option
vim.api.nvim_set_keymap('n', '<S-F6>',
"<cmd>CompilerStop<cr>" -- (Optional, to dispose all tasks before redo)
.. "<cmd>CompilerRedo<cr>",
{ noremap = true, silent = true })
-- Toggle compiler results
vim.api.nvim_set_keymap('n', '<S-F7>', "<cmd>CompilerToggleResults<cr>", { noremap = true, silent = true })
Command | Description |
---|---|
:CompilerOpen |
Shows the adecuated compiler for your buffer's filetype. |
:CompilerToggleResults |
Open or close the compiler results. |
:CompilerRedo |
Redo the last selected option. |
:CompilerStop |
Dispose all tasks. |
This is what happen when you select build & run
, build
, or run
in the compiler:
compiler.nvim will look for the conventional entry point file for the current language you are using. To achieve this, it searches in your current working directory for the next files
Language | Default entry point | Default output |
---|---|---|
asm x86-64 | ./main.asm | ./bin/program |
c | ./main.c | ./bin/program |
c++ | ./main.cpp | ./bin/program |
c# | ./Program.cs | ./bin/Program.exe |
dart | ./lib/main.dart | ./bin/main |
elixir | ./mix.exs | ./_build/ |
f# | see here | ./bin/ |
flutter | ./pubspec.yaml | ./build/ |
go | ./main.go | ./bin/program |
java | ./Main.java | ./bin/Main.class |
javascript | ./src/index.js | |
kotlin | ./Main.kt | ./bin/MainKt.class |
lua | ./main.lua | |
make | ./Makefile | |
perl | ./main.pl | |
python | ./main.py | ./bin/program |
r | ./main.r | |
ruby | ./main.rb | |
rust | ./main.rs | ./bin/program |
shell | ./main.sh | |
swift | ./main.swift | ./bin/program |
typescript | ./src/index.ts | |
visual basic .net | see here | ./bin/ |
zig | ./build.zig | ./zig-out/bin/build |
This is how the compilation results look after selecting Build & run program
in c
For more info see wiki - when to use every option
If you want to have more control, you can create a .solution.toml
file in your working directory by using this template where every [entry] represents a program to compile
[HelloWorld]
entry_point = "/path/to/my/entry_point_file/main.c"
output = "/path/where/the/program/will/be/written/hello_world"
arguments = ""
[SOLUTION]
executable = "/program/to/execute/after/the/solution/has/compiled/my_program"
If any of these files exist in your current working directory, they will be automatically detected and displayed on Compiler.nvim:
Build automation utility | More info |
---|---|
Makefile | +info |
CMakeLists.txt | +info |
build.gradle | +info |
package.json | +info |
Create ~/c-example/main.c
and paste this code. Then do :cd ~/c-example/
to change the working directory to the project.
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
Open the compiler and select Build and run
. You will see the compilation results.
- I get errors when compiling: You have to
:cd /your/project/root_dir
before calling Compiler.nvim. - How can I auto
:cd
my projects? Use this fork of the pluginproject.nvim
. - I don't have time to read: If you prefer you can try NormalNvim which comes with the compiler pre-installed. Just open some code and hit F6!
- How can I add a language that is not supported yet? Fork the project, and go to the directory
/compiler/languages
. Copyc.lua
and rename it to any language you would like to add, for exampleruby.lua
. Now modify the file the way you want. It is important you name the file as the filetype of the language you are implementing. Then please, submit a PR to this repo so everyone can benefit from it. - How can I change the way the compiler works? Same as the previous one.
- How can I add an automation build utility that is not supported yet? Fork the project, and go to the directory
/compiler/bau
. Copymake.lua
and rename it to the build automation utility you want to add, for examplemaven.lua
. Now modify the file the way you want. Note that you will also have to modify/utilities-bau.lua
and change the functionget_bau_opts()
so it can parse the utility you want to add. Then please, submit a PR to this repo so everyone can benefit from it. - Is this plugin just a compiler, or can I run scripts too? Yes you can. But if your script receive arguments, we recommend you to use the terminal instead, because creating a
.solution.toml
file just to be able to pass arguments to your simple shell script is probably a overkill, and not the right tool. - I'm a windows user, do I need to do something special? You have to enable WSL, and run nvim inside. Otherwise it would be impossible for you to install the required dependencies.
- How can I disable notifications when compiling? Check here.
The workflow of game development is essentially very different from just compiling and running a program. It involve loading editing and running scenes. While there is no way for us to support it directly, here I offer you some tricks:
To Build and run a godot scene
, use the command godot /my/scene.tscn
on the terminal. This works really well: It's fast and simple.
The recommended way is to have 2 monitors, one with nvim and your code, and another one with your unity scenes to run the game. Unity has some terminal commands, but working with them is quite a painful experience.
If you want to help me, please star this repository to increase the visibility of the project.
rust, go, swift
require the user to initialize the package before using its respective clicargo, go, swift
. Let's explain this on+more info
. β Let's evaluate the pros and cons of auto initializing a package if do not exist already, so this process is automatic.Building systems β meson
is planned. Auto discovery of options defined by the user is planned.cli β pip
look for improvements.cli β cargo
look for improvements.cli β dart pub
look for improvements.cli β go build
look for improvements.cli β elixir
look for improvements.cli β zig
look for improvements.Building systems β maven
is planned. Auto discovery of options defined by the user is planned.- Consider adding rake support.
- Better Windows compatibility when not using WSL: The commands
rm -rf
andmkdir -p
only exist on unix. To support Windows without WSL we should run the equivalent powershell command when Windows is detected. - Aditionally, we will also have to compile for
asm
win64 architecture, if the detected OS is windows. - Aditionally, we will also have to add an option to compile for
Build for windows (flutter)
.