An experimental Rust frontend framework.

Component Binding

Bind components to the DOM. Quasar keeps your views up-to-date when you mutate component (or application) state.

Type Safe

Your component types are propogated into events. Never null. Never undefined. Never TypeError. No need to check to see if it quacks like a duck.

Swappable Templating

Bring your own templating engine. Quasar has an out-of-the-box default, but it is trivial to swap for your own templating engine.

This page is powered by Quasar (see how) and compiled to ASM.js. See also the WASM variant (coming soon).

Pick a templating engine:

The examples on this site were built for each of these engines. Toggle between engines to see how they differ.

Bart

Compile-time templates inspired by Mustache.

Maud

Rust macro-based compile-time templates.

Mustache

Traditional runtime template engine with Mustache.

...and supporting your preferred templating engine is probably trivial.

A Basic Counter

Data Observers

Accessing data makes your component an observer of that data. Modifying data causes its observers to be rerendered. This is all enforced by Rust's type system.

(And yes, you can undermine these behaviors by using interior mutability)

DOM Patching

Rendering templates is accomplished through DOM patching. Currently Quasar embeds morphdom.js for this, but be great to explore alternative ideas for updating the DOM.

To Do App

Isomorphic Rendering

The same rendering can be used both server and client side.

That said, the patterns and details for doing so are not established yet.

Extensible Rendering

By exposing the node and app in the Renderable trait, it should be possible to explore ideas for more complex templating engines that enable features like 2-way binding or custom attributes with associated behavior.

Emscripten Ecosystem

Lots of existing rust crates will work like normal. Of course, there is still room for this story to improve. For example, syntect could replace highlight.js on this page soon. And reqwest could eventually enable web clients that work both server and client side.

Backend Integration

No demo yet.

The story around integrating quasar with a backend is still just conceptual.

Should I use Quasar?

Probably Not. Nothing about Quasar is stable. Performance is probably attrocious. Rendering has plenty of quirks. The API is still plenty awkward. And major refactors are still anticipated.

How can I contribute?

There are tons of ways to contribute to Quasar, directly or indirectly, depending on your interests. The possibilities include contributing to the design the architecture and API to building demos to a variety of other ideas that more generally benefit Rust's emscripten ecosystem. There are issues tracking these and several other areas that could benefit from contributors, and feel free to file any new issues.

And of course, a star on GitHub encourages further development: Star on Github