Open-source alternatives to Tj Ejs

Handlebars.js is a JavaScript templating engine used to generate HTML and other text formats by combining static templates with dynamic data. It functions as a logic-less template engine, separating presentation from business logic by restricting the complexity of expressions within templates. The project includes a precompiled template compiler that converts template strings into executable JavaScript functions. This mechanism reduces runtime overhead and improves rendering performance by shifting the compilation process to a build step. The engine provides a custom helper framework for ext

doT is a compiled JavaScript template engine and rendering system used to generate dynamic text and HTML for both browser-based interfaces and Node.js server-side environments. It transforms template strings into executable JavaScript functions to produce text output across different runtime environments. The system focuses on pre-compiling template source files into standalone JavaScript modules at build time. This process eliminates runtime compilation overhead, increases execution speed, and prevents malicious code injection. The engine supports logic-based interpolation using conditional

Template.js is a JavaScript template engine designed for parsing and rendering dynamic HTML content in both browser and server-side environments. It functions as a frontend logic library that manages complex user interfaces through data injection, template composition, and extensible rendering logic. The engine distinguishes itself by prioritizing performance through build-time template compilation, which transforms template files into executable modules or functions to minimize runtime overhead. It also incorporates a secure execution sandbox that restricts template logic to a controlled sco

Mustache.js is a logic-less JavaScript templating engine and implementation of the Mustache specification. It merges data objects with text templates to generate formatted output, ensuring consistent rendering across different programming languages by forbidding complex logic within the templates. The system distinguishes itself by using a logic-less approach to data binding, relying on simple variable interpolation and conditional block rendering. It supports modularity through partial template inclusion and allows for extended functionality via lambda functions that transform blocks of temp

Pug is a template engine and compiler that transforms whitespace-sensitive shorthand syntax into standard HTML. It functions as both a Node.js template engine for server-side rendering and a browser-side precompiler for client-side templating. The system converts template files into executable JavaScript functions to increase rendering speed. This allows for the generation of full HTML documents by combining dynamic data and logical structures, either on a server or as standalone JavaScript files for execution directly in the browser. The engine manages the translation process through HTML t

Assemble is a static site generator and build pipeline system that compiles markdown, templates, and data into static HTML files. It functions as a markdown-to-HTML converter and a data format transformer capable of moving content between JSON, YAML, XML, PLIST, and CSV formats. The project features a pipeline-based build process where users can define ordered sequences of data transformations and file processing steps. It includes project scaffolding tools to bootstrap directory structures and configuration files from predefined boilerplates. The system manages content through collection-ba

art-template is a JavaScript templating engine and HTML template compiler that transforms custom syntax and script statements into optimized HTML output. It functions as a precompiled template engine that converts template source into standalone JavaScript functions to render dynamic content from data. The engine features a template inheritance framework that organizes layouts through nesting, blocks, and inclusions to create reusable components across multiple files. It incorporates automatic output sanitization and encoding to prevent cross-site scripting attacks. The system includes capab

art-template is a JavaScript template engine and server-side rendering engine. It functions as an abstract syntax tree compiler that translates template source code into executable JavaScript to generate HTML or text output. The engine includes a template inheritance system that allows the definition of base layouts and reusable content blocks. It also provides a template debugging tool that maps syntax and runtime errors to exact line numbers within the source files.

hogan.js is a logic-less template compiler and Mustache templating engine. It transforms static templates into executable JavaScript functions to generate data-driven strings without using conditional or looping logic. The system focuses on precompilation to eliminate parsing overhead during runtime execution. This includes a precompiled template library and a command line interface for converting template files into optimized JavaScript. The engine handles dynamic content generation through template compilation and data rendering. It supports reusable UI fragments via partials and allows fo

This library provides a framework for building custom template systems and rendering dynamic content within web applications. It offers a set of standardized interfaces and tools designed to handle the parsing of template files, the transformation of data into structured output, and the management of template loading from various storage locations. The component distinguishes itself through a modular architecture that supports incremental output streaming, which processes content in chunks to reduce memory usage and improve response times. It also includes integrated security features that au

vue-loader is a Webpack loader that compiles single-file Vue components into executable JavaScript modules for the browser. It functions as a compiler that splits templates, styles, and scripts from a single file into a bundled module, converting templates into optimized JavaScript render functions for both client and server environments. The project provides a system for routing style blocks through specialized CSS loaders to enable scoped and isolated component styling. It also includes a development utility for hot module replacement, which updates components in the browser in real-time wi

Vue is a progressive, component-based JavaScript framework designed for building reactive user interfaces and single-page applications. It centers on a declarative template system that transforms HTML into efficient render functions, allowing developers to organize complex interfaces into isolated, reusable units that synchronize automatically with application state. The framework distinguishes itself through a dependency-tracking reactivity system that monitors data access during rendering to trigger precise updates. It provides a flexible architecture that supports both incremental adoption

Nunjucks is a JavaScript templating engine used for generating dynamic HTML by combining data with templates. It serves as an asynchronous template processor that allows for non-blocking execution within filters and parallel processing of iterations. The engine features a template inheritance system where base skeleton structures are defined and extended by child templates to fill specific content blocks. It includes a security utility for context-aware HTML escaping to prevent cross-site scripting during the rendering phase. The library provides capabilities for server-side rendering and da

Liquid is a secure template engine and markup language used to generate dynamic HTML or text by combining static templates with backend data. It functions as a web template renderer that transforms markup into final output while restricting available logic to prevent arbitrary code execution. The engine focuses on secure markup execution, providing a restricted environment where user-provided templates cannot access sensitive system data. It utilizes a safe evaluation sandbox to ensure that only a predefined set of instructions can be executed. The system includes capabilities for template s

Templ is a type-safe HTML templating engine and UI framework for Go. It provides a system for building reusable HTML components that compile into Go code for server-side rendering, ensuring type safety and compile-time validation of data and logic. The project features a dedicated language server that provides autocomplete and syntax validation for template files within supported code editors. It employs compile-time code generation to transform a custom template language into Go source code, enabling the creation of modular HTML fragments and logic blocks. The framework includes automated s

Tera is a server-side rendering engine and template engine for Rust. It is designed to generate dynamic text by injecting data into predefined template files, utilizing a syntax compatible with Jinja2 and Django. The engine supports a variety of text generation tasks, including the creation of web pages via HTML rendering, the automation of email templates, and the production of environment-specific configuration files.

This project is an educational guide focused on building modular web applications using native PHP features. It demonstrates how to construct a functional application architecture from the ground up without relying on external third-party frameworks. The guide centers on implementing core architectural patterns, including a request router that maps incoming HTTP paths to specific controller logic and a dependency injection container that manages object lifecycles and class requirements. By decoupling components through automated dependency resolution, the project emphasizes maintainability an

Nickel is a web framework for the Rust programming language designed to handle HTTP requests and responses. It functions as a server-side toolkit that provides integrated routing, middleware, and JSON deserialization. The framework utilizes a middleware-based request pipeline to insert custom logic and state management into the request-response cycle. It also includes a server-side template engine for generating dynamic HTML pages by merging data with markup templates. The project covers high-level capabilities for REST API development, web application routing, and global error handling to i

This project is a comprehensive educational resource and learning roadmap for mastering the Node.js runtime. It provides a structured curriculum that guides developers from basic syntax through advanced asynchronous patterns and professional architectural practices. The resource covers the internal architecture of the engine, specifically explaining how the event loop and thread pool handle non-blocking I/O and concurrency. It includes tutorials on the evolution of asynchronous flow control, moving from callbacks and promises to modern syntax patterns. The guide also addresses various applic

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

Crow is a minimalist C++ micro web framework designed for building fast web servers and REST APIs. It provides a lightweight toolkit for web development in C++, offering core routing and request handling capabilities. The framework includes a built-in JSON parser for converting strings into structured data and an HTML template engine for generating dynamic web pages on the server. It also functions as a WebSocket server library to enable bidirectional, real-time communication between servers and web clients. Additional capabilities include a middleware-based request pipeline for executing sh

This project is a project scaffolding engine and template-based code generator. It provides a modular project template library and a command-line tool designed to generate standardized directory structures and configuration files from reusable skeletons. The system uses variable injection and custom delimiters to render project skeletons into concrete files. It includes a mechanism for synchronizing shared template collections via version control repositories and a utility for uploading generated files and secrets to remote hosts using secure shell protocols. The tool covers automated projec

This project is a technical study guide and architectural analysis of the Vue.js framework. It serves as an educational resource for understanding the implementation of a reactive framework, providing source code analysis and architectural visualizations to explain the internal workings of the Model-View-ViewModel pattern. The project focuses on the mechanics of reactive framework implementation, specifically how dependency tracking, getters, and setters are used to synchronize state with a user interface. It includes detailed examinations of the virtual DOM and the process of reconciling ele

mp-html is a component for rendering and editing HTML content within various mini program environments, such as WeChat and Alipay. It functions as an HTML to mini program parser that converts HTML tags, tables, and SVGs into compatible elements for mobile mini program frameworks. The project includes a cross-platform rich text editor for modifying HTML content and a renderer capable of displaying Markdown syntax and LaTeX formulas through modular extensions. Its broader capabilities cover media interaction management, anchor-based navigation, and user interaction controls for text selection

This library is an integration bridge for embedding React components within Ruby on Rails views and controllers. It provides a hybrid frontend architecture that allows developers to mix traditional server-rendered templates with isolated interactive components. The project differentiates itself through a comprehensive server-side rendering wrapper that generates HTML on the server to improve load speeds and search engine visibility. It includes a client-side hydration manager that automatically mounts and unmounts components by scanning the document for markers and synchronizing with navigati

This project is an implementation of React Server Components, providing a full-stack component architecture that blends server-side rendering with client-side interactivity. It enables the development of web applications where server-only components for data fetching and interactive client components coexist within a single component tree. The system focuses on server-client data orchestration, allowing for the execution of server functions and database mutations across the network boundary. It distinguishes itself through a hybrid component architecture that shifts component execution to the

This project provides a server-side language runtime and a standardized Docker image for deploying applications across different operating systems. It functions as an execution environment for generating dynamic HTML, JSON, and XML content, while also serving as a command line interface for automation scripts and background jobs. The runtime is designed for extensibility through a C-based extension architecture, allowing the loading of custom modules for specialized functionality. It supports multiple server application interfaces, including a FastCGI web interface for high-performance commun