What is the best alternative to Marko Widgets?

Functional approach.

Deku can render it's components and data server side, then it sends those components as HTML to the browser. This ensures faster initial loading time and SEO friendliness out of the box, since it's indexed as any other static website by search engines.

Since Deku is very lightweight and has a rather small API, there's not much to learn. It's pretty easy to get started and build something with it.

Riot takes the expressions from a DOM tree and stores them in an array. Each of these expressions points to a DOM node. On each cycle these expressions are compared to the values in the DOM. So when a value has changed, Riot automatically updates the corresponding node. This way the operations are...

Riot is made to be used with websites of any kind, so it's built to be easy and lightweight, but still maintaining all the needed features for a UI library. It's only 2.5 KB in size when minified. So it can also be used for mobile web apps without requiring much bandwidth to download.

Riot components use custom tags which are nothing more than familiar HTML tags coupled with JavaScript. This eliminates the need to learn another templating language or syntax. For example: <todo> <h3>TODO</h3><ul> <li each={ item, i in items }>{ item }</li...

Web Components are a collection of specifications released by W3C as a way to reduce the complexity of web apps by creating reusable components. Browser support is currently poor for web components, however Polymer is developed to make web components compatible with modern browsers.

It provides a base component.

HTML markup as it can be a non-string.

Vue can easily be integrated with other front-end libraries. This makes it an extremely versatile tool and it's easy to fix its shortcomings or missing features by just plugging in another library.

Vue.js weighs in at 16kb min+gzip.

Very useful.

Blocks.js is just 16.5KB minified and gzipped. So it's pretty small.

Apps developed with blocks.js are modular in structure and make use of reusable objects. This makes these applications very maintainable.

Library contains UI components like Datagrids, Forms, Tabs, SideBars, Toolbars and more

Only two files need to be included 1 .css and 1 .js, together they are only 365 kb. regarding to amount of components it is very small.

any component is well documented and have an easy api to access validation, dataloading and handling user events.

Inferno weighs in at 9kb gzipped, which is light-weight.

Inferno is one of the fastest UI libraries around and widely considered the fastest.

Use it however you want in a framework of your own custom design. When things change in the industry, swap things out instead of being locked in by someone else's design.

To get started is extremely simple. It has a low learning curve.

Even the most complicated GUIs are bug-free most of the time.

The company behind webix is really quick in answering any questions you have on their forum or via email.

Knockout uses HTML5 data attributes to bind HTML elements to data objects in javascript. This allows more work to be done by the framework rather than requiring you to specify where data should be bound in the javascript. The data binding is very intuitive as the bindings are done within the HTML i...

Has a low entry barrier and an easy learning curve. It's especially easy to learn for beginners.

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 struct...

Full support for Typescript built in

Configured to give you the most common use cases by convention, which means you only need to change the default configuration for edge cases. This means that for normal cases far less boiler plate code has to be written.

Aurelia includes native support for ES6 and even comes with a Gulpfile which helps with transpiling ES6 code to ES5.

The size when gzipped is only 3kb, and performance is as good as (or even faster than) React itself.

Avoids having to learn an entire new paradigm, and makes it easy to switch between the two libraries later on.

Preact CLI gives you a perfect scoring PWA out-of-the-box with no configuration.

Since every single UI component is created independently in JavaScript, it becomes very easy to reuse them throughout your app without having to re-write them.

React can render it's components and data server side, then it sends those components as HTML to the browser. This ensures faster initial loading time and SEO friendliness out of the box, since it's indexed as any other static website by search engines.

Instead of relying on the DOM, React 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.

CanJS supports all modern browsers and IE9+.

CanJS is a collection of individual libraries, each separately available as npm packages. It's easy to use just what you need.

CanJS's model layer (can-connect), support real-time updates to lists without adding any additional code.

Most other frameworks either offer a huge API to deal with model and view synchronization, or defer to other libraries & plugins to cater for relatively simple use cases. Mithril's API is tiny but complete. The natural reaction is to assume something is missing, but as you build you realise...

Mithril's loading times are very fast. This is because it's templates are compiled first and then served to the browser and because it uses a virtual DOM. The virtual DOM is a virtual tree containing all the nodes of the real DOM, every time anything changes in the virtual DOM, Mithril does...

Most MVC frameworks use HTML templates to render their views. They are good and useful because they are easy to read and understand. But they add more complication to an app because it's practically a new language and syntax that needs to be learned. Mithril argues that separating markup from...

Ractive has a concept of proxy events, which translate a user action (e.g. a mouseclick) defined via an event directive into an intention (e.g. 'select this option'). This allows you to handle user interaction in a readable, declarative fashion. on-click='activate' with arguments:

Two-way binding can be turned off by those that are concerned it may be a source of bugs.

They have a great interactive tutorial which makes the learning process easy peasy. You will get into it within a couple of minutes.

Amber is written in itself, including the parser and compiler, and compiles into efficient JavaScript, mapping one-to-one with the JS equivalent.

Amber includes an integrated development environment with a class browser, workspace, transcript, object inspector and debugger.

A lightweight view class is provided but there is no default templating method implemented. Because views are minimal it allows for much more freedom to implement views however you would like, and because of this freedom it's possible to write views to more uniquely adapt to a problem. User in...

Backbone can be combined with any library of your choosing, giving you the ultimate flexibility in creating customized solutions for unique projects. Even the only two backbone requirements, jQuery and underscore can be replaced with equivalent libraries like zepto or lo-dash.

Backbone has existed longer than most frameworks, and has a large following of users and projects using it as a framework.

Lack of run-time exceptions makes it easy to produce large swathes of reliable front-end code without drowning in tests.

As Elm was designed as a front-end langauge, it has out of the box support for things like DOM-element creation, letting programmers focus on their application logic, rather than implementation details specific to the web.

ML static typing is great because it's always there, you just choose how explicit you want to be and how much you want the compiler to do.

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.

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.

Ractive fully supports a templating language. To be more precise, views are written with a variant of Mustache, which is also extended to support inline JavaScript expressions. Soon it will be able to support other templating languages.