Authored by Yiyi Sun, AppRun in a lightweight (3KB) library that uses TypeScript as the development language and takes inspiration from Elm, style model-view-update architecture and event publication and subscription.
Binding.scala - No Official Site
Binding.scala is a one-way data-binding library written in Scala, although it targets both JavaScript and JVM. Binding.scala can be used as a reactive templating language in both web and desktop GUI development. It enables you use native XHTML literal syntax to create reactive DOM nodes, which are able to automatically change whenever the data source changes... Binding.scala has more features and less concepts than other reactive web frameworks like ReactJS.
Bobril takes inspiration from React and Mithril. It is fast, low size framework with rendering based on Virtual DOM. The main focus is on speed and simplicity of code generation...Content and behavior of any page can be defined simply by composing JavaScript objects.
CanJS is a client-side JavaScript framework used to build rich web interfaces. It provides state-management, templates, custom elements, and a whole bunch more. CanJS makes it easy to to do the common stuff, while helping you build the impossible.
Choo is a functional library for building user interfaces. It's small (4KB) and supports server rendering. They believe frameworks should be disposable, and components recyclable. They don't want a web where walled gardens jealously compete with one another. By making the DOM the lowest common denominator, switching from one framework to another becomes frictionless.
CxJS, or simply Cx, is a feature-rich JavaScript framework for building complex web front-ends, such as BI tools, dashboards and admin apps. Modern frameworks such as React and Angular provide an excellent base for building UI components, however, component implementation and many other application aspects are left to the developer to figure out. CxJS tries to fill that gap and provide the all necessary ingredients required for modern web applications.
Billed as a "functional and reactive JavaScript framework for predictable code" Cycle.js is primarily the work of André Staltz. Cycle’s core abstraction is your application as a pure function main() where inputs are read effects (sources) from the external world and outputs (sinks) are write effects to affect the external world. These I/O effects in the external world are managed by drivers: plugins that handle DOM effects, HTTP effects, etc.
Dyo is a JavaScript library for building user interfaces. Light — weight library with a small API surface that allows you to build simple and complex component based user interfaces. Declarative Efficiently render just the right components in response to data, making your code more predictable and easier to reason about.
One of the important principles behind Dojo is accessibility, which makes me think it's a potential candidate for projects in government and higher education, where there are often stringent compliance requirements. Dojo 2 is grounded in the belief that accessibility is as important online as it is in our physical environments, and architects of both share a similar responsibility to provide access to all. Internationalization, or i18n, is the process of decoupling an application from a particular language or culture, and is a major requirement of most enterprise applications.
Domvm is a, "thin, fast, dependency-free vdom view layer". Like Vue, it can be used as a jQuery replacement. Similar to React, it leaves concerns beyond views to other libraries (but provides a good list of options). domvm is a flexible, pure-js view layer for building high performance web applications. Like jQuery, it'll happily fit into any existing codebase without introducing new tooling or requiring major architectural changes...As a view layer, domvm does not include some things you would find in a larger framework. This gives you the freedom to choose libs you already know or prefer for common tasks. domvm provides a small, common surface for integration of routers, streams and immutable libs.
DoneJS - No Official Site
DoneJS is a successor to JavaScriptMVC, which was first released in 2008. DoneJS offers everything you need to build a modern web app. It comes with a module loader, build system, MVVM utilities, full testing layer, documentation generator, server side rendering utilities, a data layer, and more. Its completeness is itself a feature.
Etch - No Official Site
Although Etch can be used for front end web applications, its target usage is in Atom packages and the Electron desktop framework. Etch is a library for writing HTML-based user interface components that provides the convenience of a virtual DOM, while at the same time striving to be minimal, interoperable, and explicit. Etch can be used anywhere, but it was specifically designed with Atom packages and Electron applications in mind.
Gruu is a relatively new framework by Marek Łabuz. I believe that none of the existing libraries is perfect. Each time a new library/framework is created, some new idea is revealed. No matter if the new library is good or bad. It always brings something unique that is valuable. Many frontend libraries rely on a render function that is called each time something changes, no matter what the change affects. It leads to unnecessary renders of the parts of the application that has not changed, but still we have to check it because we don't know for sure... Gruu gets rid of a render function. Instead, it renders only once at the beginning, then it changes only this parts of the view that have actually changed without rendering whole components.
Glimmer is part of the Ember ecosystem and even uses the Ember CLI to manage projects. As mentioned when discussing Ember, it is a large framework. Glimmer provides Ember developers with a lighter weight option for building single page apps. If needed, Glimmer components can be dropped directly into Ember without a problem.
Hyperapp - No Official Site
Coming in at a very slender 1KB, Hyperapp is a library with a minimalist API. It does, however, support server rendering. It is a JavaScript library for building web applications. Hyperapp was born out of the attempt to do more with less. We have aggressively minimized the concepts you need to understand while remaining on par with what other frameworks can do. Hyperapp's design is inspired by The Elm Architecture. Create scalable browser-based applications using a functional paradigm. The twist is you don't have to learn a new language. Out of the box, Hyperapp combines state management with a VDOM engine that supports keyed updates & lifecycle events --- all with no dependencies.
Hyperdom - No Official Site
Formerly named, Plastiq, Hyperdom, is a "fast, feature rich virtual-dom framework for building dynamic browser applications." Hyperdom applications are made of regular JavaScript objects that represent application state with render() methods that define how that state is represented in HTML. Hyperdom supports a simple event-update-render cycle, promises for asynchronous operations, JSX, non-JSX, client-side routing, SVG, two-way data binding, and optimises for performance, developer usability and simplicity of application architecture.
Framework agnostic, hyperHTML was created to, "simplify DOM performance best practices... is 100% ECMAScript compliant and it weighs in at less than 4Kb". It's nothing more than a function, that works bound with DOM nodes and fragments as context. You bind your target node once, or even more if you don't care, and you render the same template literals over and over simply passing new data.
Ivi - No Official Site
It seems that nowadays many people in javascript community were brainwashed that small library size is a synonym to fast performance and simple implementation. In reality it usually means that library is using different tricks to reduce code size by using inappropriate data structures (slower performance), initializing data structures at runtime (slower bootstrap performance), reusing code for many different data types (slower performance), etc. Library size in ivi library is at the bottom on the list of priorities: Correctness, Consistency / Predictable Behavior, Performance / Developer Experience and Library Size.
Using the MVVM pattern, Knockout is a library that has been around for a while. Knockout is a JavaScript MVVM (a modern variant of MVC) library that makes it easier to create rich, desktop-like user interfaces with JavaScript and HTML. It uses observers to make your UI automatically stay in sync with an underlying data model, along with a powerful and extensible set of declarative bindings to enable productive development.
Maquette is a lightweight (3KB) library inspired by React, Mithril and Mercury. Maquette is a virtual DOM implementation that excels in both speed and simplicity. It solves the problem of keeping the user interface in sync with underlying data. Maquette allows you to specify the UI using plain Javascript. This makes maquette easy to learn, easy to debug and easy to deploy. Maquette is very unopionated by design, making integration with other frameworks and libraries as painless as possible.
A product of eBay Open Source, Marko is a reactive front end framework that emphasizes UI performance. Similar to Vue, you can use single file components that include component logic, template and CSS. While many of the features in Marko were inspired by React, Marko and React offer very different usability and performance characteristics. Marko was designed to avoid almost all boilerplate and is more closely aligned with HTML. In almost all cases, a Marko UI component will require less lines of code than its React JSX equivalent while maintaining readability and allowing the same expressiveness as JSX.
Mithril is a lighweight framework. Unlike React, it incudes functionality for routing, XHR and state management. Why use Mithril? In one sentence: because Mithril is pragmatic. This 10 minute guide is a good example: that's how long it takes to learn components, XHR and routing - and that's just about the right amount of knowledge needed to build useful applications. Mithril is all about getting meaningful work done efficiently. Doing file uploads? The docs show you how. Authentication? Documented too. Exit animations? You got it. No extra libraries, no magic.
A small (7KB) library, Moon positions itself as an alternative to React, Vue and Mithril. Moon is a minimal, blazing fast library for building user interfaces. It combines the positive aspects of popular libraries into one small package. It's super lightweight, and includes advanced optimizations to ensure fast render times. The API is small and intuitive, while still remaining powerful. Moon is compatible with IE9+. Moon aims to combine the best parts of best known libraries into a single, lightweight package, while providing improved performance.
Nerv is a new framework out of China. It bills itself as a, "blazing fast React alternative, compatible with IE8 and React 16." In fact, you can convert a React app to Nerv simply by adding an alias in your webpack config. All of that and a library size of 4.4 KB. Because it is so new and makes claims of superior performance vs React --- some members of the React community asked for clarification on those claims, as well as more information about Nerv.
NX is the work of Bertalan Miklos, JavaScript engineer at RisingStack. NX is a modular front-end framework - built with ES6 and Web Components. The building blocks of NX are the core, the middlewares, the components and the utilities. These are all hosted in separate GitHub repos and npm packages. The NX core is a tiny library, responsible for one thing only. It allows you to create dumb components and to augment them with middlewares. A component executes its middlewares when it is attached to the DOM and it gains all the extra functionalities from them.
petit-dom - No Official Site
Authored by Yassine Elouafi and one of the fastest in performance benchmarks, petit-dom takes a minimalist approach: Diff algroithm is based on pre-optimizations described at https://neil.fraser.name/writing/diff/ and the algorithm presented in the paper "An O(ND) Difference Algorithm and Its Variations. There is also an excellent article which explains how the algorithm works. The article includes a GUI application to play with the algorithm.
Pux is a framework that uses PureScript, a strongly-typed, functional programming language that complies to JavaScript. There are currently problems with performance: The slow performance arises from translating Pux's (smolder) virtual DOM to React's virtual DOM. The goal is to write a purescript virtual DOM module for smolder, which would avoid that translation step and could be optimized for a monadic datastructure. I suspect this would achieve performance on par with Halogen.
Originally created for use on the Guardian website, Ractive is a reactive, template-driven UI library. Unlike other frameworks, Ractive works for you, not the other way around. It doesn't have an opinion about the other tools you want to use with it. It also adapts to the approach you want to take. You're not locked-in to a framework-specific way of thinking. Should you hate one of your tools for some reason, you can easily swap it out for another and move on with life.
Authored by Juha Lindstedt, RE:DOM is a small (2KB) and fast UI library. In fact, it's one of the best performers in the latest benchmarks. RE:DOM is a tiny (2 KB) DOM library by Juha Lindstedt and contributors, which adds useful helpers to create DOM elements and keeping them in sync with the data. Because RE:DOM is so close to the metal and doesn't use virtual dom, it's actually faster and uses less memory than almost all virtual dom based libraries, including React (benchmark).
react-lite - No Official Site
Aiming to be a lighter-weight version of React, react-lite, is an "implementation of React that optimizes for small script size". React-lite supports the core APIs of React, such as Virtual DOM, intended as a drop-in replacement for React, when you don't need server-side rendering in browser(no ReactDOM.renderToString & ReactDOM.renderToStaticMarkup).
Reflex - No Official Site
Authored by Irakli Gozalishvili of Mozilla, Reflex is a library heavily inspired by Elm. Reflex is a functional reactive UI library that is heavily inspired by (pretty much is a port of) elm and it's amazingly simple yet powerful architecture where "flux" in react terms is simply a byproduct of a pattern. In order to keep a major attraction of elm --- algebraic data types & type safety --- the library uses flow, a static type checker for JS. All types are separated from implementation though, so it's your call if you want to take advantage of it or just ignore it.
The frontend space is indeed crowded, but we honestly feel the solution is still "out there". We believe Riot offers the right balance for solving the great puzzle. While React seems to do it, they have serious weak points that Riot will solve. A major feature of Riot is custom tags (which look a lot like a Vue single file component). Riot is Web Components for everyone. Think React + Polymer but without the bloat. It's intuitive to use and it weighs almost nothing.
rxdomh - No Official Site
Although interesting, rxdomh has the look of an experimental project. It was inspired by Binding.scala and react-flyd.
San is another project from Chinese developers. San, is a MVVM component framework. Its small size (12K), good compatibility (IE6), high performance is a reliable and dependable solution for implementing a responsive user interface. San also supports data-to-view binding instructions, the most commonly used branches in business development, looping instructions, etc. in addition to supporting the syntax features of all native HTML through declarative HTML-like view templates that remain well-used on the basis of, based on the complete frame template string parsing, and build a view of layer node relation tree generated by the UI view of the quick view of a high-performance engine.
It's fair to say that no other framework has a smaller API than Simulacra. Simulacra.js returns a DOM Node that updates when an object changes. Its API is a single function, and it does not introduce any new syntax or a template language. It recursively adds metaprogramming features to vanilla data structures to work. It is a fairly low cost abstraction, though it may not be quite as fast as hand-optimized code. The approximate size of this library is ~5 KB (minified and gzipped).
Authored by Avichay Eyal, Slim.js is a lightweight web component authoring library. Slim.js is a lightning fast library for development of native web-components and custom-elements based modern applications. No black magic involved. It uses es6+DOM native API and boosts up HTML elements with superpowers.
The framework that tries not to be a framework. The syntax might look familiar, but Stem is designed to empower individual components and not the framework... Stem was designed with code maintainability as a primary purpose, regardless if your project has 100 or 100k lines of code.
Stencil is a "compiler that generates Web Components". Stencil combines the best concepts of the most popular frontend frameworks into a compile-time rather than run-time tool. Stencil takes TypeScript, JSX, a tiny virtual DOM layer, efficient one-way data binding, an asynchronous rendering pipeline (similar to React Fiber), and lazy-loading out of the box, and generates 100% standards-based Web Components that run in any browser supporting the Custom Elements v1 spec.
A modest JavaScript framework for the HTML you already have. Unlike other frameworks, Stimulus doesn’t take over your application’s entire front-end. Rather, it’s designed to augment your HTML by connecting elements to JavaScript objects automatically.
Superfine - No Official Site
Superfine is interesting in that it's authored by the same guy behind Hyperapp, Jorge Bucaran. Described as a, "1 KB VDOM builder and patch function", Superfine is a tool that can be used to build your own framework. Superfine supports keyed updates & lifecycle events --- all with no dependencies. Mix it with your favorite state management library or create your own custom view framework.
Surplus - No Official Site
Surplus is a compiler and runtime to allow S.js applications to create high-performance web views using JSX. Thanks to JSX, your views are clear, declarative definitions of your UI. Thanks to Surplus' compiler, they are converted into direct DOM instructions that run fast. Thanks to S, they react automatically and efficiently as your data changes.
Thermite - No Official Site
purescript-thermite is a PureScript wrapper for purescript-react. It does not provide all of the functionality of React, but instead provides a clean API to the most commonly-used parts of its API. It is possible to use purescript-react for more specialized use cases.
TSERS - No Official Site
TSERS stands for Transform-Signal-Executor framework for Reactive Streams. In the era of the JavaScript fatigue, new JS frameworks pop up like mushrooms after the rain, each of them providing some new and revolutionary concepts. So overwhelming! That's why TSERS was created. It doesn't provide anything new. Instead, it combines some old and well-known techniques/concepts and packs them into single compact form suitable for the modern web application development. Technically the closest relative to TSERS is Cycle.js, but conceptually the closest one is CALM^2.
Vidom - No Official Site
Vidom is just a library to build UI. It's highly inspired from React and based on the same ideas. Its main goal is to provide as fast as possible lightweight implementation with API similar to React.
Vuera - No Official Site
Vuera is an unusual library. It allows you to use React componets inside Vue and vice versa. The anticipated use cases are when migrating between React and Vue or when using both frameworks with a single project.