Fragment Executor Engine

Fragmenium

Fragmenium is a fragment execution engine. It executes HTML, CSS, and JS as fragments.

Each fragment is executed according to the reference.js file, which makes the application more dynamic, maintainable, and reusable.

All fragments are 100% cleanable. When a previous fragment is no longer needed—especially JavaScript—it can be removed completely.

Fragments are written in pure HTML, CSS, and JS. There is no fancy syntax or special rules required to get started.

Fragment Types

There are four main types of fragments, each executed at different times. In addition, there are some special fragment types.

Type: Constant

Constant fragments are executed only once when the page loads.

Type: Common

Common fragments are executed when visiting pages within a specific directory.

Type: Unique

Unique fragments are HTML-specific and represent static parts of the application. They are executed on every navigation.

Type: Specific

Specific fragments are CSS and JS-specific, designed exclusively for particular pages.

Special Fragment Types

Type: Every is a JS-specific fragment that executes every time navigation occurs.

Type: Swap is an HTML-specific fragment that supports reusability with parameters. It is not page-specific; instead, it acts like a variable with parameter functionality.

Architecture

Fragmenium is built on a fragment-based architecture that provides a true Single Page Application (SPA) experience while ensuring reusability, SEO friendly and maintainability.

A Fragmenium application is composed of both static and dynamic fragments:

• Dynamic fragments — These include Constant, Common, and Swap fragments. They typically represent reusable fragments such as header, footer, aside, or other code snippets that appear across multiple pages. Dynamic fragments are not strictly required for SEO, but they are essential for simplifying maintenance and handling frequent updates efficiently.
• Static fragments — These form the core content of the application. Static fragments are directly tied to SEO and user engagement, as they represent the unique, page-specific information that search engines index and visitors interact with.

This separation of static and dynamic fragments allows Fragmenium to balance performance and flexibility. Static fragments ensure strong search engine visibility, while dynamic fragments reduce code duplication and make updates easier across the entire application.

By combining these two fragment types, Fragmenium delivers a hybrid architecture: developers can build applications that are both SEO-friendly and highly maintainable, without sacrificing the smooth navigation and responsiveness of an SPA.

Comparison

Fragmenium is a fregment-based execution engine that offers a lightweight alternative to popular frameworks like React and Vue. While React and Vue rely on virtual DOMs, build processes, and custom syntax, Fragmenium focuses on simplicity, direct execution, and maintainability.

In summary, Fragmenium delivers a minimalistic, fregment-driven architecture that provides SPA-like experiences without build steps, heavy syntax, or large bundle sizes. Its iframe-based execution model ensures true cleanup, something React and Vue cannot achieve natively.

Use Case

Fragmenium is built for developers who want a lightweight, flexible, and cost‑efficient way to deliver modern web applications. Its fregment-based architecture makes it simple to adopt and powerful enough to handle both small and large projects.

Where Fragmenium Shines

• Small projects — Stand up quickly with no build step, no new syntax, and instant SPA‑like navigation.
• Large projects — Scales more smoothly than expected because fregments can be reused, cleaned, and maintained without heavy tooling.
• SEO‑friendly sites — Static fregments ensure valid URLs and strong search engine visibility without requiring SSR.
• Cost saving — Nothing needs to execute on the server; all fregments run directly in the browser, reducing infrastructure costs.
• Plugin & library compatibility — Fragmenium doesn’t need its own ecosystem. It can use almost any existing JavaScript plugin or framework, as long as it avoids static imports. This opens up a “sea of code” already available to developers.
• Rapid prototyping — With only ~10kb of core code and no special syntax, developers can learn.
• Clean lifecycle — JavaScript execution inside iframes ensures pure cleanup, avoiding residual state issues common in React/Vue.

Limitations

• Native app development — Fragmenium is web‑only. React Native and Vue Native extend to mobile platforms, which Fragmenium does not target.
• Community size — Fragmenium is super simple to understand, so it doesn’t require a massive community or ecosystem. However, this also means fewer ready‑made patterns compared to React/Vue.

In summary, Fragmenium shines when projects need to be lightweight, cost‑effective, and easy to maintain. It leverages the existing JavaScript ecosystem without requiring its own, making it both practical and powerful for modern web development.