Render.rs

Render.rs is a type-safe Rust template engine that brings the ergonomics of JSX to HTML and XML rendering by combining trait implementations, structs, and macros.

What is Render.rs?

Render.rs is a Rust crate that unifies tree-shaped data composition through the Render trait. As input, it takes Rust structs and functions annotated with macros like #[component], along with composable element trees built via the rsx! macro; as output, it produces rendered HTML strings via the html! macro or direct .render() calls. The crate is open source under the MIT license and designed specifically for Rust's type system.

Key Features

• Render trait — Any struct implementing this trait becomes a renderable component, enabling custom components with no runtime errors.
• #[component] macro — Turns a plain Rust function into a component; the function's parameters become struct fields, and visibility flows from the function to the generated struct.
• rsx! macro — Composes elements with JSX-like syntax inside Rust code, allowing conditional logic and expressions via Rust's normal syntax.
• html! macro — Convenience macro that builds a component tree with rsx! and immediately renders it to a String; useful for HTTP responses or generated files.
• Automatic escaping — Attribute values and plain strings are escaped through the render::html_escaping module, and the raw! macro lets you inject unescaped HTML intentionally.

Who is it for?

• Rust web developers — Those building server-rendered HTML with Rocket or similar frameworks can use Render.rs to generate views with full compile-time type safety, unlike JSON-oriented template engines.
• Rust library authors — Developers who want to ship reusable component libraries can leverage the visibility propagation: a pub component function produces a pub struct with pub fields.
• Teams migrating from dynamic templates — Teams using Handlebars or similar specs that force runtime type validation can move to Render.rs to catch template type errors at compile time.

What can you do with Render.rs?

• Generate HTML5 pages: Compose a full document with a doctype, head, and body by combining built-in components like HTML5Doctype with custom components.
• Build composable view components: Create components that accept children (e.g., a Page component taking title and children parameters) and nest them arbitrarily.
• Render safely escaped content: Use the automatic escaping for dynamic strings and the raw! macro only when you need to inject trusted HTML, preserving both safety and control.

How does Render.rs work?

Defining a component is as simple as writing a function annotated with #[component]; the macro generates a struct implementing Render. Inside that function, the rsx! macro builds a tree of elements and expressions. Calling the html! macro on a component instance renders the tree to a string, processing attributes and text through the escaping module in the process.

Alternatives

• Handlebars — A JSON-oriented template spec that does not guarantee Rust's type safety, forcing you to write extra tests for view types.
• typed-html — A library that focuses on strict HTML spec validation but does not allow arbitrary composition of custom elements like Render.rs does.

Pricing

Render.rs is free and open-source, distributed under the MIT license.

FAQ

Is Render.rs free?

Yes, Render.rs is free and open source under the MIT license, so you can use it in commercial and personal projects without cost.

What macros does Render.rs provide?

Render.rs provides three main macros: #[component] to define components from functions, rsx! to compose element trees with JSX ergonomics, and html! to render a tree directly to a string.

How does escaping work in Render.rs?

Attribute values and plain strings are escaped using the render::html_escaping module by default. If you need to insert raw HTML, you can wrap a string in the raw! macro, which bypasses escaping for that value.

Can I build custom components?

Yes, any struct implementing the Render trait is a component. The #[component] macro makes it easy to turn a function into a component, and the rsx! macro lets you compose components and standard HTML elements together.

What limitations does Render.rs have?

The current version does not type-check HTML tags or attributes — it accepts any key and string value — focusing instead on type-safe custom component composition. If you need strict HTML spec validation, typed-html may be a better fit.