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."
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.
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.
> 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.
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.
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.
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.
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.
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 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 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.
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.
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 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).
> 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.
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.
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])
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 :)
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.
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.
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).
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.
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.
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
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 :(
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).
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
Onivim 2 ticks a lot of boxes for me. I daily drive VSCode and I enjoy it, but vim bindings are an absolute must, and the various extensions available always leave a little to be desired, even if they do work pretty well.
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.
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.
- 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 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.
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.
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.
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.
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
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#.
"∙ 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."