The settings engine is a system-wide cascading and granular solution.
Inspired by VSCode's settings system, it takes it a few steps further by making the cascade not just vertical but horizontal too. Settings can be derived from combinations of users, roles, modules, rules, or any factor really.

Primitives are raw format entities, as in an image, or a piece of text.
Keeping a distinction between primitives and entities allows for multiple semantic layers. It means that, for example, one could style a button based on it being text, inside a box, a button as a whole, a confirmation button, a "positive" button, a primary button.
It also means that functions and tools can be reused across all domains.

Entities are the cornerstone of MatGen.
Metadata is conceived as data itself, and no information is discarded.
In an internet landscape rife with dis- and misinformation, data duplication, conflicting reports, the only way to ensure clarity is to collectively curate self-validating ontologies.
A car is an entity, a book is an entity, a cat is an entity, a song is an entity.
By making sure that we all share the same definitions, communication is made clearer, and accessibility is mathematically assured.

Users can also create custom, private entities, for those edge cases which might not apply to everyone, but knowledge sharing is encouraged by design.

Actions are business logic. They take Processors, Utilities and all other tools and craft logical sequences. They are what ties all subsystems together.

Utilities are useful low-level functions such as string modifiers (e.g. UPPERCASE to camelCase).
These functions appear in both the source code and are exposed to users. Much like a 3D printer, users can build and expand MatGen, by using MatGen itself.

Processors are large, multi-step functions that parse, convert, bridge, modify, etc.
Processors which have already been developed are:
- the Semantic Book PDF Extractor, which maintains structural integrity of a book, including all footnotes, links, references, endnotes, etc. and retains layout information
- the LaTeX Typesetter, which takes semantically built texts (including texts extracted with the Semantic Book PDF Extractor) and uses the theming engine to automatically produce professionally typeset books ready for publication. This typesetter is already being successfully used at Iskra Books
- various other PDF tools, web scrapers, etc.

Components are conceived as purely declarative structural elements, regardless of which module is using them.
A header is a header whether it's in HTML or Qt, and MatGen does not logically differentiate the two. Of course granularity is possible should a user choose to separate the two, but the UI construction language acts as a bridge over different frameworks, allowing for the same component-based architecture to be rendered with whichever framework or method suits the task at hand.
MatGen is built with reusability as a philosophy.

Assets are cross-theme elements which might need to be reused across domains.
These include icons, fonts, textures, etc.

MatGen uses a cross-domain, granular, cascading theming system, inspired in equal parts by CSS and KDE Plasma's theming engine.
Total separation of concerns is applied within each component of a theme, allowing for mixing and matching, as well as easy variations.
Its philosophy is the complete opposite of Tailwind CSS, as it focuses on clean semantics and maintainibility rather than quick deployment.
The theming engine is also declarative and language-agnostic, which means that a theme will apply equally to HTML outputs, LaTeX outputs, SVG outputs, etc.

MatGen templates are conceived as pre-made canvasses which can be fully modified. Rather than using prescriptive templating engines where users are beholden to the template creator's decisions, MatGen templates are simply pre-defined folder structures which, seeing as they are simply folders with files, can be modified directly by the user, allowing for quick iteration on pre-made designs and structures.
Semantic information is still retained, so a user can still keep track of where they built from scratch and where they built with templates.

Both frontend and backend UIs feature status pages for the whole MatGens system and each and every subsystem and module, out of the box.

MatGen is installed using an intuitive deployment wizard, allowing users to quickly deploy systems locally and remotely, on self-hosted as well as managed servers.

Local installs have a Development output, remote installs have a Staging output and a Live output. All three can be accessed locally and compared easily. Multiple Development and Staging outputs can be set up for different purposes

MatGen follows the principles of semantic versioning, by incrementing versioning numbers based on different scales of changes. These are customisable to suit every user's needs.

Versioning is automated according to specific conditions for each different entity. Through automated code analysis, versioning for code is capable of tracking whether changes are breaking, bug fixes, typo fixes, etc.
Specific conditions can be set, such as incrementing the primary version number for a song whenever a new instrument is introduced, or whenever the lyrics for a section are finalised. Sensible defaults will be in place, but community-created workflows will be made available to all through a community marketplace.

Syncing and backing up can be done both manually and automatically, and they can be triggered by any semantic condition, like everything else in MatGen.

MatGen's semantic versioning system automatically creates a rich, incremental history of everything, so syncing and backing up data is merely a matter of cloning data to a secondary location. Both local and remote repositories are supported.

MatGen is encrypted based on permissions. This means non-authorised users whoare not even allowed to open specific files ar ephysically not able to.
MatGen also encrypts all data by default while the system is not running. This avoids changes from happening away from the Registrar's watchful eye.

Permissions are deeply granular, operating on both vertical and horizontal levels.
Events can be restricted by role, clearance level, domain, meeting customised conditions, timespans, and much more.
This makes managing permissions within larger organisations a breeze.

Every event that happens in MatGen is registered semantically. What this means is that as much metadata as possible is collected for each event, including timestamps, domains, spot within a specific pipeline and much more. Debugging is an inherent feature, as everything can be traced under every aspect, automatically.

Any event or task can be scheduled absolutely or relatively, regularly or irregularly.
Semantic changes can trigger specific sequences of events. For example, finishing the composition of a song could trigger emailing parts to musicians immediately, scheduling social media posts to go out exactly a week before the publication of the sheet music on a website, which can be set to any arbitrary date.

Clever temporary folder solutions allow for critical error handling and job resumption, as well as schedule recovery in case of any kind of failure.

Tracking every change in both time and space means that larger-scale changes can be traced and analyzed more easily, allowing for unique insights.

Users can customise eveyr aspect of their notifications, allowing them to adapt the system to their preferred workflow and/or organisational policies.

Notifications can be set for every subsystem and module, mediated through user, role, domain permissions and much more.

Due to the semantic registration of each and every event, automatic, deterministic documentation is a reality, through a combination of rich metadata, clever natural language generation and ontological validation. This includes changelog and release note generation.

Documentation is generated at every level of the pipeline, from high-level overviews to individual function descriptions. Custom documentation can also be added, and specific workflows can be automatically documented as well, with different language choices for different purposes and users.

Full integration with MatGen's semantics means that task management is no longer a tedious, manual affair. Ontology-based planning means that templates and sensible defaults guide the planning process.

Versioning and task management exist in a dialectical relationship, where an entity's version updating can trigger specific task-related processes, and specific-task related processes can trigger versioning changes.

MatGen's component system is platform-agnostic, so any UI will run on any compatible framework. If you build a UI for a website, it will also work as native software, bypassing typical performance issues you would get with Electron-like solutions.

MatGen's base UI is fully customisable and hackable, with accessibility integrated by design.

Every functionality is available to end users through the UI. There is full feature parity between the GUI and the terminal.

The Website module is an SSG-inspired module with dynamic functionality and rich semantics built in, built using semantic folders, outputting and using HTMX, CSS, and alpine.js.
A complete separation of concerns means allows for the inclusion of a full-featured accessibility panel on every website by default, as well as a cookie and storage consent management interface, which is compliant with every internet privacy law worldwide.

The Publication module uses LaTeX bindings to generate perfectly typeset books and documents. Outputs are built semantically and according to both industry-standard and user-definable rulesets.
It supports multiple languages, both left-to-right and right-to-left, and advanced table, diagram, figure and equation support, as well as footnotes, end notes and margin notes.

The Forms module uses the Website module as its base, and allows for the creation of online forms (like Google forms) with automated data collection into MatGen databases. Potential uses could be user onboarding, ontological curation, surveys, polls, etc.
As these are part of a MatGen install, privacy is ensured by default and they can integrate will subsystems, ensuring rich semantics and scheduling options, and much more.

The Social Media module allows users to generate social media posts in various formats and for various platforms, using either the Website module as its engine or the yet-to-be-developed Image module.
Like all modules and subsystems, it features full integration with all functionality, which is especially useful when it comes to scheduling.

MatGen does not use relational databases. The database is made up of raw folders and files, where each folder is the equivalent of a row in a database. This means that users can work with large files directly and see their changes be automatically applied to their outputs.

Each folder-entity has swathes of metadata. A song is no longer a smattering of files, but a single folder, where there is only one file at any given time, due to the automatic versioning system. Old version can still be accessed, but only the latest and most relevant one is visible at a glance. Opening a song within the MatGen UI comes with sensible defaults that adapt to the entity type. Opening a piece of writing brings up a different view to suit that format, and so on.

Indexing is performed using symlinks, automatically, at the points of creation and modification. This means that common searches can be pre-compiled into symlink directories, allowing every existing file operation to be performable on different semantic levels.
Each file exists thus in multiple domains, both in vertical hierarchies and horizontal relationships. MatGen pretty much treats hierarchical categories like tags, eliminating neither.