When comparing Knockout vs Ractive, the Slant community recommends Knockout for most people. In the question“What are the best React.js alternatives?” Knockout is ranked 6th while Ractive is ranked 16th. The most important reason people chose Knockout is:
Ranked in these QuestionsQuestion Ranking
Pro Easy data binding
Pro Easy to learn
Has a low entry barrier and an easy learning curve. It's especially easy to learn for beginners.
Pro Great documentation
The excellent tutorials with built-in exercises are a great learning experience, even for people without prior MVVM and data binding experience.
Pro Legacy browser support
Supports a large number of browsers, including IE6.
Pro Built in templating
Bindings in Knockout can also be used to control the generated structure of the HTML. There are bindings provided to allow for iteration and conditionals. The structure of the html reflects the structure of the data so iterative elements are bound to arrays in the data model. Having the HTML structure maintained by bindings keeps the templating simple, easy to read, and maintain.
Knockout also allows for string based templating so you can use whatever templating library you prefer.
Pro Dynamic models help with keeping the code simple and clean
Models in Knockout can be watched to keep the page data up to date by using observable objects. The observables notify Knockout when data is changed and automatically updates the page when this happens. By having Knockout maintain this relation, it keeps the front end code cleaner and simpler, and by enforcing a consistent pattern with observables the methodology can be more robust.
Pro Lightweight and plays nicely with other libraries
Pro It's only a library
Knockout does one thing, and does it well. It doesn't try to take on more than one area. It does MVVM data binding and that is it.
Pro Very flexible
One can do a lot of things and it keeps self references and other types of loops under control.
Pro Simple manageable modules
Using components is a great way of breaking up large modules into simpler ones.
Pro Live, reactive templating
Ractive.js is a template-driven UI library, but unlike other tools that generate inert HTML, it transforms your templates into blueprints for apps that are interactive by default.
Pro Powerful and extensible
Two-way binding, animations, SVG support and more are provided out-of-the-box – but you can add whatever functionality you need by downloading and creating plugins.
Pro Supports a true templating language
Pro Virtual DOM
Instead of relying on the DOM, Ractive implements a virtual DOM from scratch, allowing it to calculate precisely what needs to be patched during the next screen refresh. This is orders of magnitude faster than fiddling with the DOM itself.
Con Can become complex once the application grows large
Knockout leaves the application structure to the developer and it can become quite complex and unmanageable in the hands of a beginner once the application grows large and complex.
Con Seems to be dead
KO has been stuck at version 3.4 for a long time, and there's not a lot of community activity.
Con Two way binding requires a little extra work
When allowing users to edit existing data, the two-way binding of observables means you'll need to have to save original values before they're edited, to make comparisons or revert if the user cancels the action.
Con Slower than others when amount of objects grows
Knockout has a bad performance when the dealing with large amount of objects. You can see more here.
Con Ractive's two way binding can be a source of bugs
Two-way data-binding means that a HTML element in the view and an Ractive model are binded, and when one of them is changed so is the other. One-way data-binding for example does not change the model when the HTML element is changed.
This is a rather controversial subject and many developers consider two-way data binding an anti-pattern and something that is useless in complex applications because it's very easy to create complex situations by using it and being unable to debug them easily or understand what's happening by just looking at the code.