Onivim 2: Lightweight, Modal Code Editor(github.com)
github.com
Onivim 2: Lightweight, Modal Code Editor
https://github.com/onivim/oni2
77 comments
Good for you guys and gals trying to find ways to pay yourselves.
See also, if curious, from 2018:
https://news.ycombinator.com/item?id=16995876
https://news.ycombinator.com/item?id=16673267
https://news.ycombinator.com/item?id=16995876
https://news.ycombinator.com/item?id=16673267
And if its not obvious, the links are for Onivim1, rather than Oni2.
There is a somewhat out of date document on the motivation behind starting Oni2 here: https://github.com/onivim/oni2/blob/master/docs/MOTIVATION.m...
The big changes from Oni1 to Oni2:
- We moved from Typescript/Electron to ReasonML/Revery for a native rendering stack which is much faster (startup/in general) and generally lighter weight, with a solid FFI story for native libs (Like libvim below, but also stuff like tree-sitter etc).
- We moved from neovim via RPC to libvim, a fork of vim as a library, with motivation behind that change in the doc above, and why vim over nvim in the GitHub README for libvim.
This is allowing us to bring forward the things people liked in Oni1, but drop stuff that people didn't, with Electron being an obvious big one. The end result, combined with harnessing the VSCode ecosystem should hopefully make a compelling editor.
There is a somewhat out of date document on the motivation behind starting Oni2 here: https://github.com/onivim/oni2/blob/master/docs/MOTIVATION.m...
The big changes from Oni1 to Oni2:
- We moved from Typescript/Electron to ReasonML/Revery for a native rendering stack which is much faster (startup/in general) and generally lighter weight, with a solid FFI story for native libs (Like libvim below, but also stuff like tree-sitter etc).
- We moved from neovim via RPC to libvim, a fork of vim as a library, with motivation behind that change in the doc above, and why vim over nvim in the GitHub README for libvim.
This is allowing us to bring forward the things people liked in Oni1, but drop stuff that people didn't, with Electron being an obvious big one. The end result, combined with harnessing the VSCode ecosystem should hopefully make a compelling editor.
I’m still using Sublime Text because of its superior performance compared to most other editors, and I’ve recently been super impressed by the NeoVintageous plug-in [1].
It has a very complete feature parity with Vim and even implements many popular Vim plug-ins such as surround, unimpaired and abolish.
[1] https://github.com/NeoVintageous/NeoVintageous
It has a very complete feature parity with Vim and even implements many popular Vim plug-ins such as surround, unimpaired and abolish.
[1] https://github.com/NeoVintageous/NeoVintageous
> VSCode Plugin Support
Given this, and that there's at least one vim plugin for VSCode, is Onivim a serious alternative? How does VSCode+vscodevim compare to Onivim?
Given this, and that there's at least one vim plugin for VSCode, is Onivim a serious alternative? How does VSCode+vscodevim compare to Onivim?
Oni was/is build completely on top of neovim and oni2 turned vim (not neovim) into a library and builds on top of that.
I suppose the vscode plugin support is implemented in similar fashion as coc[1] does it.
1: https://github.com/neoclide/coc.nvim
I suppose the vscode plugin support is implemented in similar fashion as coc[1] does it.
1: https://github.com/neoclide/coc.nvim
It's actually a bit different - VSCode has a 'front-end' process and a 'back-end' process (the extension host).
The extension host is larger than just handling language services - it handles additional functionality, like source control, menus, language configuration - the full protocol is defined here: https://github.com/microsoft/vscode/blob/master/src/vs/workb...
We aim to integrate with that back-end extension host process - in other words, to support the `vscode` extension API surface, not just language support.
Because of the ubiquity and popularity of VSCode - the extensions tend to have significant investment and be of very high-quality, so we'd like to be able to leverage that wholesale.
The extension host is larger than just handling language services - it handles additional functionality, like source control, menus, language configuration - the full protocol is defined here: https://github.com/microsoft/vscode/blob/master/src/vs/workb...
We aim to integrate with that back-end extension host process - in other words, to support the `vscode` extension API surface, not just language support.
Because of the ubiquity and popularity of VSCode - the extensions tend to have significant investment and be of very high-quality, so we'd like to be able to leverage that wholesale.
I feel like a curmudgeon when say this but tools that make me leave my terminal ultimately never sit well. It always feels so limiting when you hit the point where you’re digging through the guts of some framework that basically a web app packaged as a desktop app.
I see why people use it and maybe it not even a web app but I’m old enough to know vim gets me everything I need and using some ide desktop app is going to cost me more time in the long run.
For context, one of my biggest pet peeve is my dependence on desktop web browser. I wish I could actually be productive using something lynx.
I see why people use it and maybe it not even a web app but I’m old enough to know vim gets me everything I need and using some ide desktop app is going to cost me more time in the long run.
For context, one of my biggest pet peeve is my dependence on desktop web browser. I wish I could actually be productive using something lynx.
I love vim and have never met someone who used it more fluently than me. Yet I find it lacking. I can never get IDE features like code navigation and completion to really work. I use YouCompleteMe like everyone else but it’s just not as good as Jetbrains. It randomly stops working. Parameter hints don’t really work. This is for C++, by the way. The JavaScript situation is even worse.
My dream is also for vim to be the integrated, full-featured software package you describe, but at the moment I find it falls short.
My dream is also for vim to be the integrated, full-featured software package you describe, but at the moment I find it falls short.
I find CoC to be much better than YouCompleteMe for both C++ and Python. Regardless, it's still not as good as Jetbrains. I don't know if it's a fundamental limitation of the underlying language Server (ccls) or CoC has issues with itself, but i experience random breakages in the autocompletion all the time too.
I love Vim, but since I started working in TypeScript/React every day it is basically unusable (syntax highlighting / code formatting cannot match VSCode) so I'm now running VSCode + Vim extension which is kinda meh, but serviceable.
One of these days I will get around to contributing to a Vim plugin or two to help improve Typescript / TSX support.
One of these days I will get around to contributing to a Vim plugin or two to help improve Typescript / TSX support.
I've had a different experience. Neovim + coc-tsserver and a syntax highlighting plugin works really well, and VSCode + Vim extension is unbelievably slow on my machine.
Which syntax highlighting plugin(s) are you using? Do you have syntax highlighting for functional components/hooks in .tsx files / can you share a config? Would love to give it a try.
I have spent many hours trying to get that work with no success. I've searched public .vimrc configs on github using typescript plugins and none of them gave me any type of syntax highlighting that compared to VSCode.
I have spent many hours trying to get that work with no success. I've searched public .vimrc configs on github using typescript plugins and none of them gave me any type of syntax highlighting that compared to VSCode.
I haven't used VSCode enough to consider myself knowledgeable about it's syntax highlighting or auto-indentation, so caveat emptor.
I use CoC.nvim using the coc-tsserver plugin to get Typescript completion/jump to definition etc, ALE to get ESLint warnings, HerringtonDarkholme/yats.vim (A Typescript syntax, Neovim comes bundled with this, but the bundled version might be out of date), and maxmellon/vim-jsx-pretty for JSX syntax highlighting and indentation (vim-jsx-pretty's auto indentation is not 100%, but it works well enough).
My colorscheme is tomasiser/vim-code-dark, in case that matters. Example screenshot: https://i.imgur.com/6UzKtU2.png
I use CoC.nvim using the coc-tsserver plugin to get Typescript completion/jump to definition etc, ALE to get ESLint warnings, HerringtonDarkholme/yats.vim (A Typescript syntax, Neovim comes bundled with this, but the bundled version might be out of date), and maxmellon/vim-jsx-pretty for JSX syntax highlighting and indentation (vim-jsx-pretty's auto indentation is not 100%, but it works well enough).
My colorscheme is tomasiser/vim-code-dark, in case that matters. Example screenshot: https://i.imgur.com/6UzKtU2.png
Thanks for sharing! My current setup is:
Plug 'HerringtonDarkholme/yats.vim'
Plug 'mhartington/nvim-typescript', { 'do': './install.sh' }
Plug 'pangloss/vim-javascript'
Plug 'maxmellon/vim-jsx-pretty'
Not too far off, but different.
I'll adjust a bit and see how it looks on some production code.
Plug 'HerringtonDarkholme/yats.vim'
Plug 'mhartington/nvim-typescript', { 'do': './install.sh' }
Plug 'pangloss/vim-javascript'
Plug 'maxmellon/vim-jsx-pretty'
Not too far off, but different.
I'll adjust a bit and see how it looks on some production code.
I’ve had success with my config, it’s kind of large and i’m slowly slimming it down. But maybe it will help.
https://github.com/monsonjeremy/dotfiles/tree/master/config/...
https://github.com/monsonjeremy/dotfiles/tree/master/config/...
Try CoC and whatever language servers you need. Nvim becomes really powerful with this combo.
> Yet I find it lacking. I can never get IDE features like code navigation and completion to really work.
Same here. In the end I just gave up and installed Emacs with vim key bindings (evil mode). Took a while to set things up, though, albeit not so much the vim bits, which were fine, but the IDE features.
Vim is fine as a framework for text editing but as an application it's a bit lacking.
Same here. In the end I just gave up and installed Emacs with vim key bindings (evil mode). Took a while to set things up, though, albeit not so much the vim bits, which were fine, but the IDE features.
Vim is fine as a framework for text editing but as an application it's a bit lacking.
I agree. I've been using vim for about a decade now. I love the editing experience. I really dislike the "IDE" experience (plugins, file navigation, etc).
I've been seriously considering writing a new vim clone in go and build what I would consider the ultimate editor. Basically as if vim had been written today.
I've been seriously considering writing a new vim clone in go and build what I would consider the ultimate editor. Basically as if vim had been written today.
Onivim might not be for you :) But our project under the hood, libvim [1], might be useful for you to start (if it's easy to create bindings from C in Go).
There's a cool non-Onivim usage of it called Paravim [2] (and the same author also used it for Vim-Cubed [3])
- [1] https://github.com/onivim/libvim/blob/master/src/libvim.h
- [2] https://github.com/paranim/paravim
- [3] https://github.com/oakes/vim_cubed
There's a cool non-Onivim usage of it called Paravim [2] (and the same author also used it for Vim-Cubed [3])
- [1] https://github.com/onivim/libvim/blob/master/src/libvim.h
- [2] https://github.com/paranim/paravim
- [3] https://github.com/oakes/vim_cubed
Just to be clear, I was making my comment more in the context of vim than Onivim. I maybe should have said that originally, my bad. I backed Onivim and am keeping a close eye on it. Maybe I won't need to (try to) make my editor :)
Ah, sorry I misread :) Thanks for supporting the project, really appreciate it!
Have you tried emacs with evil-mode? It could save you a lot of trouble, as the ultimate editor is already written. ;-)
Oh them's fightin' words. Actually I have tried evil mode. Although it's been years since I last did. I remember it being one of the better vim emulators out there. I should give it another go.
I want to use Vim, but I don't want to set up all the plugins and figure all that out. I want it to "just work" like VSCode does. VSCode's Vim emulation isn't that great, though.
Onivim 2 for the record is not a web app, it's a completely native app built in ReasonML (OCaml) and they even had to build their own GUI framework (Revery) to make this editor. It's extremely fast.
Onivim 2 for the record is not a web app, it's a completely native app built in ReasonML (OCaml) and they even had to build their own GUI framework (Revery) to make this editor. It's extremely fast.
You can embed neovim inside VSCode nowadays, you should check it out.
You know, I'm not even 30, and I'm somewhat in the same camp; I pretty much live inside tmux whenever I can, and I feel like I'm relatively productive with it.
With my current job, I'm forced to use IntelliJ (a lot of the build scripts depend on it, and the project is too big for Eclim), and while there's nothing wrong with IntelliJ, I simply don't feel half as productive with it as I do within Vim and tmux.
With my current job, I'm forced to use IntelliJ (a lot of the build scripts depend on it, and the project is too big for Eclim), and while there's nothing wrong with IntelliJ, I simply don't feel half as productive with it as I do within Vim and tmux.
I feel the same way, though I would want something a bit heavier than VIM. Something with syntax hinting/completion, and a file browser on the left.
Basically just VS Code but in a terminal window. Really wish something like that existed (or maybe it does but I don't know about it).
Basically just VS Code but in a terminal window. Really wish something like that existed (or maybe it does but I don't know about it).
You can have all that in vim - it just takes some set up.
syntax highlighting: https://github.com/sheerun/vim-polyglot
completion: https://github.com/neoclide/coc.nvim
file browser: https://github.com/preservim/nerdtree
how to install these plugins: https://github.com/junegunn/vim-plug
syntax highlighting: https://github.com/sheerun/vim-polyglot
completion: https://github.com/neoclide/coc.nvim
file browser: https://github.com/preservim/nerdtree
how to install these plugins: https://github.com/junegunn/vim-plug
Thank you so much! Will try this out.
This is how I feel as well. But I know a lot of folks use the terminal inside of e.g. VS Code for this.
I wonder what they'd say in response?
For me, a lot of the value is in having a single app that I can turn to for most of my dev tasks. That app happens to be a terminal (with different projects contained in different tmux sessions).
I wonder what they'd say in response?
For me, a lot of the value is in having a single app that I can turn to for most of my dev tasks. That app happens to be a terminal (with different projects contained in different tmux sessions).
For my part, I use IntelliJ for Java, vscode for everything else, and iterm2 for more intensive terminal work, all running in fullscreen mode and/or tiled using Rectangle. On OS X.
It gives something very close to the "hands never leave the keyboard" experience that I like about living in the terminal, while also letting me fall back to a mouse when that would be quicker or easier. It also gets me the nice things that I expect are only possible to do well in a graphical environment, such as minimaps and displaying graphical information like plots or dependency graphs.
I do find that my text-mode editor skills are weakening over time, and that does have an impact on my productivity when I have to do a decent whack of work on a remote server. But that's not something that I personally have to do often enough to be a major concern.
It gives something very close to the "hands never leave the keyboard" experience that I like about living in the terminal, while also letting me fall back to a mouse when that would be quicker or easier. It also gets me the nice things that I expect are only possible to do well in a graphical environment, such as minimaps and displaying graphical information like plots or dependency graphs.
I do find that my text-mode editor skills are weakening over time, and that does have an impact on my productivity when I have to do a decent whack of work on a remote server. But that's not something that I personally have to do often enough to be a major concern.
Fully agree. Primary reason I use emacs is because I can run it in my terminal (and I never got the hang of modal editing). All my readline shortcuts just work everywhere there, and copypasting from the tmux scrollback buffer is a breeze
Ever tried https://github.com/jyp/boon? Modal editing for emacs, describing itself as ergonomic and respecting emacs conventions. Disclaimer: not using myself, i'm a happy http://kakoune.org/ user.
Looks really nice, and it's cool to see something like this implemented in reason (OCaml really), but I don't see $35 worth of value compared to VSCode or MacVIM.
If you're going to stare at your editor much of every workday, does the price really matter that much? Even if it only makes you a bit happier than alternatives do, the price difference per hour used will be tiny.
I'd wager most software developers can shell out $35 on a whim.
I'd wager most software developers can shell out $35 on a whim.
Right, we figured if it can save you just a few hours of configuration, it's paid for itself.
Yeah $35 is nothing really. If I end up using it I'd gladly pay that to support them, even if I don't use it commercially.
Look at what something like Visual Studio or IntelliJ cost for a commercial license :D This is nothing.
Look at what something like Visual Studio or IntelliJ cost for a commercial license :D This is nothing.
The licensing is a bit complicated. It is not really open source, until later, when it is:
"∙ Free for non-commercial and educational use."
"∙ Commercial use requires the purchase of a license."
and then
"Because of the support we've received from open source communities, we've decided to dual-license the code after 18 months - every commit, starting with 017c513, will be dual-licensed via the MIT License 18 months from that commit's date to master."
"∙ Free for non-commercial and educational use."
"∙ Commercial use requires the purchase of a license."
and then
"Because of the support we've received from open source communities, we've decided to dual-license the code after 18 months - every commit, starting with 017c513, will be dual-licensed via the MIT License 18 months from that commit's date to master."
We decided to try a new approach to see how it works for funding - funding open source projects is _hard_!
We wanted a model where, unlike completely proprietary licenses, the source code could be available - and, worst case, if something happened to the project - users could still have full access to it. And that all the work is eventually available in general.
Our first OSS drops - from 18 months ago - are coming in next month (July 2nd), so that'll be exciting. It will be interesting to see how it works out.
We wanted a model where, unlike completely proprietary licenses, the source code could be available - and, worst case, if something happened to the project - users could still have full access to it. And that all the work is eventually available in general.
Our first OSS drops - from 18 months ago - are coming in next month (July 2nd), so that'll be exciting. It will be interesting to see how it works out.
> worst case, if something happened to the project - users could still have full access to it
Can you put in a formal license statement saying that each change will become mit-licensed 18 months after it's committed? That way, there's no ambiguity if development stops and releases stop getting put in the oni2-mit repository.
Can you put in a formal license statement saying that each change will become mit-licensed 18 months after it's committed? That way, there's no ambiguity if development stops and releases stop getting put in the oni2-mit repository.
I don't envy you... And as a software dev you don't want to be spending hours on legal stuff either.
I do love the way you have the price so low.
I do love the way you have the price so low.
For sure... drafting EULAs, working with lawyers, setting up a sales pipeline is not the fun stuff.
Would much rather work on bug fixes and features! Just a necessary evil to be able to fund development. In an ideal world - could just write open source software and not worry about paying bills.
Would much rather work on bug fixes and features! Just a necessary evil to be able to fund development. In an ideal world - could just write open source software and not worry about paying bills.
It is really intriguing to see how this works for them. Making money from normal open source projects is really hard. I am really hoping to see some innovation in this sector (FOSS+Economical sustainability) sooner rather than later.
I think once a program is established and has all its main features in there and polished, the 18 month old version may not be very different than the current version for practical purposes. I.e. if this model works, it may only work well while they're getting started and adding new useful primary features.
Even in vim new features often have me check which version I'm running. I'd say that when you start using more than the basic features then updates start becoming interesting.
The other post about Github sponsorship works; it means the code remains open source and the application free to use, whilst the developers get paid for contributing to it.
That said, I think it's mainly down to companies that use the open source software to start paying for it. All companies that use open source software - and be fair, this is pretty much all software companies - should reserve some budget to sponsor and donate to open source project and developers.
Second, there's a lot of open source projects whose developers are paid for by a company, e.g. Linux, Chromium, etc. That code is still open source and free, AND the developers get paid.
That said, I think it's mainly down to companies that use the open source software to start paying for it. All companies that use open source software - and be fair, this is pretty much all software companies - should reserve some budget to sponsor and donate to open source project and developers.
Second, there's a lot of open source projects whose developers are paid for by a company, e.g. Linux, Chromium, etc. That code is still open source and free, AND the developers get paid.
Does anyone know why Oni ditched neovim, which they used in the original Oni editor, and instead turned vim into a library (libvim) for Onivim2?
https://github.com/onivim/libvim#why-is-libvim-based-on-vim-...
Guts of it is that Neovim didn't play nicely with their OCaml build and Vim did. Rather than invest time in working through the problem, they went ahead with Vim but remain open to supporting Neovim.
Guts of it is that Neovim didn't play nicely with their OCaml build and Vim did. Rather than invest time in working through the problem, they went ahead with Vim but remain open to supporting Neovim.
> Rather than invest time in working through the problem
I don't think this is a fair characterization. We've made significant investments in both Neovim and Vim, and carefully considered the trade-offs.
> Guts of it is that Neovim didn't play nicely with their OCaml build and Vim did
This was a smaller consideration - but more fundamentally, the model Neovim uses for input - queuing it on an event loop and handling it asynchronously - is at odds with what we required - to be able to process the input -> handle updates synchronously.
There was a significant amount of incidental complexity in the architecture of our V1 to fit that asynchronous model - we wanted to avoid that for V2, and we switched to Vim because it fit that model.
I don't think this is a fair characterization. We've made significant investments in both Neovim and Vim, and carefully considered the trade-offs.
> Guts of it is that Neovim didn't play nicely with their OCaml build and Vim did
This was a smaller consideration - but more fundamentally, the model Neovim uses for input - queuing it on an event loop and handling it asynchronously - is at odds with what we required - to be able to process the input -> handle updates synchronously.
There was a significant amount of incidental complexity in the architecture of our V1 to fit that asynchronous model - we wanted to avoid that for V2, and we switched to Vim because it fit that model.
Apologies, I didn't mean to insinuate that you were taking shortcuts or making frivolous choices. My attempt to summarize obviously lost the nuance of the decision.
I think the link summed it up well, near the end
> this was purely a constraint-based technical decision
I think the link summed it up well, near the end
> this was purely a constraint-based technical decision
Is this another electron ide that takes minutes to copy paste in?
We built a new UI framework to support development called Revery: https://github.com/revery-ui/revery
It's inspired by ReactJS, and has a similar API, but actually compiles to native code (not javascript). So you have a React-like developer experience, but with native perf.
It's inspired by ReactJS, and has a similar API, but actually compiles to native code (not javascript). So you have a React-like developer experience, but with native perf.
That looks really nice - great job! There’s been a great amount of innovation in GUI libraries in the past two years. What’s the ffi story here? Can it be used as the frontend for a rust or C# application?
Thanks ComputerGuru! :) Certainly, Revery is just putting together the building blocks the ReasonML and OCaml communities have developed. Inspired by ReactJS and Elm.
Revery supports the same FFI as OCaml [1] - C-style linking. I believe Rust would be straightforward to integrate that way - I'm not sure about C#.
- [1] https://caml.inria.fr/pub/docs/manual-ocaml/intfc.html
Revery supports the same FFI as OCaml [1] - C-style linking. I believe Rust would be straightforward to integrate that way - I'm not sure about C#.
- [1] https://caml.inria.fr/pub/docs/manual-ocaml/intfc.html
No, it's using Reason/Revery.
I'm an advanced Vim user. I compile Onivim from source every couple of months to see what progress is like. My biggest problem with Onivim is that some of the design decisions reek of a design/development team that doesn't really grok Vim. Even if it was feature complete, it would be a slower Vim with a flashier UI and inconsistencies between the Onivim UX and Vim UX. As a specific example, the way Onivim uses tabs/splits makes it a non-starter for me.
I'm not really sure what the target customer/market is...Perhaps beginner Vim users that want a better modal editing experience than the Neovim plugin for VS Code provides, without having to sacrifice VS Code plugins? In any case, props to the Onivim team for the progress/momentum behind the project.
I'm not really sure what the target customer/market is...Perhaps beginner Vim users that want a better modal editing experience than the Neovim plugin for VS Code provides, without having to sacrifice VS Code plugins? In any case, props to the Onivim team for the progress/momentum behind the project.
Thanks for checking out the project!
This is one of the biggest pieces feedback we've received both the tabs / splits in particular [1], and the more general issue of broader Vim compatibility [2].
We actually use a forked Vim implementation under the hood (libvim [3]) - as the modal-editing engine. So Onivim, in theory, _could_ support everything. The main issue is 'wiring up' features from libvim to our front-end.
We'll be focusing on this in our next milestone (July-Sep) - with the high level goals of supporting more traditional Vim workflows, Vim tab support, along with VimL plugin support and init.vim/vimrc compatibility.
Ultimately it's a prioritization problem - so having feedback like yours is really helpful, so that we can focus on the right priorities for that work.
- [1] https://github.com/onivim/oni2/issues/592
- [2] https://github.com/onivim/oni2/issues/1551
- [3] https://github.com/onivim/libvim
This is one of the biggest pieces feedback we've received both the tabs / splits in particular [1], and the more general issue of broader Vim compatibility [2].
We actually use a forked Vim implementation under the hood (libvim [3]) - as the modal-editing engine. So Onivim, in theory, _could_ support everything. The main issue is 'wiring up' features from libvim to our front-end.
We'll be focusing on this in our next milestone (July-Sep) - with the high level goals of supporting more traditional Vim workflows, Vim tab support, along with VimL plugin support and init.vim/vimrc compatibility.
Ultimately it's a prioritization problem - so having feedback like yours is really helpful, so that we can focus on the right priorities for that work.
- [1] https://github.com/onivim/oni2/issues/592
- [2] https://github.com/onivim/oni2/issues/1551
- [3] https://github.com/onivim/libvim
I think you are pretty accurate in your assessment of the target market. The way I'd phrase it is Sublime Text, with VS Code extensions and modal editing. I don't imagine the target users want anything beyond the modes and text handling, particularly the way Vim handles tabs and splits.
This is based on me personally. I use the vim plugin in VS Code. I wish it was closer to real Vim keybindings, search etc but I want to keep the overall handling of tabs and files.
So Onivim is very interesting to me, I have purchased it, because it looks like it will give me the combination of speed, plugins and conventional editing experience that I'm looking for.
This is based on me personally. I use the vim plugin in VS Code. I wish it was closer to real Vim keybindings, search etc but I want to keep the overall handling of tabs and files.
So Onivim is very interesting to me, I have purchased it, because it looks like it will give me the combination of speed, plugins and conventional editing experience that I'm looking for.
(Dev on Oni2)
We are adding Vim-style tabs as well (i.e. tabs are a view on to buffers, where a buffer can be any split etc as expected).
That said, you are right that a lot of people in Oni1 were interested in a "modern" (in heavy quotes there) way of doing tabs, where a split could have its own tabs etc, as is the way in VSCode etc.
We are adding Vim-style tabs as well (i.e. tabs are a view on to buffers, where a buffer can be any split etc as expected).
That said, you are right that a lot of people in Oni1 were interested in a "modern" (in heavy quotes there) way of doing tabs, where a split could have its own tabs etc, as is the way in VSCode etc.
I'd really love a proper IDE that works inside a terminal, I suppose this won't either? What I'm looking for is something like VS Code but that does its window drawing using curses. Not something as barebones as vim or emacs. VS Code for terminal would really describe it well.
It would be really handy to be able to jump into a remote machine and work on code that way without much lag or the need for heavy GUI stacks <3
It would be really handy to be able to jump into a remote machine and work on code that way without much lag or the need for heavy GUI stacks <3
neovim and coc.nvim might be close to what you're looking for, if you can live with vim style motions, etc.
CoC basically takes VSCode addons and modifies them just enough to get them working in conjunction with neovim.
CoC basically takes VSCode addons and modifies them just enough to get them working in conjunction with neovim.
Thanks to you also! I can learn vim (better), that's not a huge problem (and it has some really useful shortcuts for stuff that take ages to do in a visual editor). I'm just not looking forward to figuring it all out if you know what I mean. Not trying to be critical but it does sound like a lot less accessible.
Just to give some background: I'm not someone that spends hours in an IDE every day. I'd just like something to easily install and that I can just jump into, and that makes less frequently used features easy to find with a menu or something.
Basically VS Code but then ideally in a terminal so that I can run it inside tmux, and so it will work fine over a slower connection.
VS Code, while suboptimal IMO with its Electron implementation, does show the way for an accessible IDE with great support for plugins. Even someone who doesn't use it daily can figure it out. But it's GUI only :(
Just to give some background: I'm not someone that spends hours in an IDE every day. I'd just like something to easily install and that I can just jump into, and that makes less frequently used features easy to find with a menu or something.
Basically VS Code but then ideally in a terminal so that I can run it inside tmux, and so it will work fine over a slower connection.
VS Code, while suboptimal IMO with its Electron implementation, does show the way for an accessible IDE with great support for plugins. Even someone who doesn't use it daily can figure it out. But it's GUI only :(
VS code has the new SSH mode where the language services and other plugins work on the remote machine while the rendering is local (last time I tried it I was unable to elevate permissions to write to root files which made it a PITA to do stuff like edit machine config).
Oh I didn't know of that, that sounds interesting. I'll give that a try, thanks!
There are Vim plugins that enable you to do just that. I do have a few which allows me to run a terminal command, navigate directories, manage git repo...etc all without leaving Vim
Thanks for the tip!! It sounds like something difficult to learn and set up though :) That's one thing I like about VS Code, it's quick to get into.
Do you have any guide to get started?
Do you have any guide to get started?
Hi, I didn't expect to see this on HN! Thank you for posting it. I'm the creator Onivim 2.
Still early days - and a lot of work - to realize our vision for this project :) But I'll be around to answer questions.
Still early days - and a lot of work - to realize our vision for this project :) But I'll be around to answer questions.
I love these kinds of posts, if anything just because when I look at the github page and then the language breakdown, I get to ask "What the heck is reason?" and go find out!
I'd highly recommend Jordan Walke's (creator of React) talk on the ideas behind ReasonML: React to the Future [1].
I think it's so cool that you can take the ideas of ReactJS - functional programming applied to UI - but then have a language (ReasonML [2]) that is essentially purpose built for it, with OCaml [3] powering it under the hood - a functional programming language that's been significantly invested in, both in academia and industry. And to be able to take React-the-Idea, compile it cross-platform, to native-code... and ship.
- [1] Jordan Walke - React to the Future: https://www.youtube.com/watch?v=5fG_lyNuEAw
- [2] https://reasonml.github.io/
- [3] https://ocaml.org/
I think it's so cool that you can take the ideas of ReactJS - functional programming applied to UI - but then have a language (ReasonML [2]) that is essentially purpose built for it, with OCaml [3] powering it under the hood - a functional programming language that's been significantly invested in, both in academia and industry. And to be able to take React-the-Idea, compile it cross-platform, to native-code... and ship.
- [1] Jordan Walke - React to the Future: https://www.youtube.com/watch?v=5fG_lyNuEAw
- [2] https://reasonml.github.io/
- [3] https://ocaml.org/
Something built from the ground up with vim in mind, while still supporting the mature extension ecosystem of VSCode is exciting. Glad to be able to contribute further via Patreon[0] as well.
0: https://www.patreon.com/onivim