Hello, curious soul! I'm LebCit , the developer of Aether CMS.
You can learn more about me on the About Me page of my blog.
You're also welcome to check out My Public Projects — a collection of things I've built with ❤️ for the web.

Aether CMS is licensed under the GNU General Public License v3.0 (GPLv3) .
While I've released most of my projects under the MIT License over the past decade, I chose GPLv3 for Aether because it's a complete CMS and static site generator — the result of long-term effort and dedication.
GPLv3 is still open source, but it ensures that any modified versions remain open and credit the original author. It's a way to share freely while protecting the integrity of the work behind Aether CMS.

You Can / Can't Do Under GPLv3 🧾:

Aether CMS is the result of a personal journey that began with my early experience building WordPress themes and plugins. That's where I discovered my passion for content systems and user-centric publishing tools.

Over time, I grew tired of heavyweight platforms and returned to the roots of the web — HTML, CSS, and Vanilla JS. That shift led me to explore the JAMStack and various static site generators, but I found many of them overcomplicated and bloated.

In response, I created Blog-Doc , a lightweight CMS/SSG that taught me the value of simple content workflows. Then came LiteNode , my custom Node.js framework built with performance and minimalism in mind.

Aether CMS brings all of that together — it's the product of everything I've learned and built so far. What started as a personal need evolved into something more: a fast, clean, and modular platform for developers and content creators alike.

The purpose of Aether CMS is to provide a fast, flexible, and minimal content management and site-building platform — without the bloat or overengineering found in many modern tools.

It was built from the ground up with simplicity in mind. Unlike many JAMStack tools or Node.js frameworks that feel like using a cannon to kill a fly, Aether runs on just four core modules : adm-zip , argon2 , litenode , and marked .

Originally, Blog-Doc was a personal solution to a developer's frustration. But after building LiteNode , I saw the potential to create something more complete — a tool for the wider Node.js community that values speed, clarity, and control. That vision became Aether CMS .

Aether CMS aims to strike the perfect balance between developer empowerment and user-friendliness — bringing content and code closer together in a lean, modern stack.

Aether CMS is actively maintained by a solo developer — me — and built entirely on my own time and resources. I've been in the open web and development space for over a decade, and I intend to keep improving Aether as long as I can. It's not just a side project — it's something I genuinely care about.

While development currently happens in my free time, I do plan to open the door for donations or sponsorship in the near future. The hope is to eventually reduce or even leave my day job and dedicate myself full-time to Aether CMS — continuing to improve it, support its users, and evolve it based on community feedback.

If you find value in Aether or want to help it grow, your support — whether it's feedback, sharing, contributing, or funding — can make a real difference. The long-term goal is to build a sustainable open-source project that stays fast, independent, and truly community-driven.

A 401 Unauthorized error usually means there's a problem with your authentication token or login process. Here's what to check:

• Make sure you entered the correct username and password during login.
• Verify that you're including the token in the Authorization header correctly:
  Authorization: Bearer YOUR_TOKEN_HERE
• Check if your token is expired — tokens are valid for 24 hours by default.
• If you're using a helper function like getStoredToken() , make sure it's retrieving a valid, unexpired token.
• Ensure your requests are sent over HTTPS in production environments.

If you're still receiving a 401 after checking the above, try logging in again to obtain a new token. Also make sure your user account has the necessary role or permissions for the action you're attempting.

The easiest and most powerful way to debug templates in Aether CMS is by using the dump filter. It converts any value — simple or complex — into a pretty-printed JSON string, right in the browser.

Dump Filter Example:

{{ object | dump }}

Replace object with any variable (e.g., site , metadata , posts , etc.) to inspect its full structure.

Other Useful Debug Tools:

• {{ variable | log("Message") }}
  - Console logging in the terminal (backend)
• {{#if condition}}Output{{/if}}
{{#not condition{{Output{{/not}}
  - Conditional rendering to test logic flow

While Aether's template engine (STE) looks visually similar to Handlebars — using {{ }} for expressions — it is not Handlebars .

STE is a custom-built, AST-based engine integrated into LiteNode. It combines some of the most powerful and expressive features from engines like EJS , Nunjucks , and Handlebars — but with a streamlined and enhanced syntax built for clarity and performance.

This means that while many patterns may feel familiar, trying to copy-paste Handlebars-specific helpers or advanced logic will likely result in errors or unexpected behavior.

Philosophy Behind STE:

The goal isn't to reinvent templating, but to refine it — keeping what's useful, removing what's redundant, and simplifying wherever possible. This makes STE lighter, faster, and easier to learn — but also different.

What You Should Do:

• Check the official STE syntax before using advanced template logic.
• Use the dump filter and log function to debug values and structures.
• If you're unsure about compatibility, avoid pasting code directly from Handlebars-based projects.

In short: STE may look like Handlebars — but under the hood, it's a different (and more focused) engine.

You may have noticed that many examples in the Aether documentation include empty HTML comments like <!----> between successive dynamic blocks (e.g. {{#if}} , {{#each}} , etc.).

This isn't required by STE itself — it's a formatting workaround that helps keep templates clean and readable when using formatters like Prettier .

The Problem:

Since Aether templates use the standard .html extension, formatters don't recognize STE's custom syntax. When you have multiple dynamic tags on the same line, the formatter compresses them — making complex logic hard to read.

Example Without Comments (after formatting):

{{#if condition}}{{#each items}}...{{/each}}{{/if}}

Example With Empty Comments (forces line breaks):

{{#if condition}}
<!---->
{{#each items}} ... {{/each}}
<!---->
{{/if}}

Why This Matters:

Adding <!----> ensures each block appears on its own line — improving clarity, especially in nested logic. It's a small trick that helps you see where one block ends and the next begins .

So while STE doesn't require it, we include these comments in our examples to make your templates easier to read, write, and maintain — especially when working with automated formatting tools.

Aether CMS was not generated by AI, but I did actively use AI tools like Claude , ChatGPT , and occasionally DeepSeek as part of my development process — particularly while evolving my earlier system, Blog-Doc , into what became Aether CMS.

While AI could certainly generate parts of a CMS, it couldn't meaningfully test, validate, or refine every layer — because a CMS like Aether is an entire ecosystem, not just a codebase.
More importantly, no AI would have come up with the original idea behind Blog-Doc — a CMS with an integrated static site generator that simplifies everything from a single codebase. That's not how CMS/SSG systems are traditionally designed, but I built Blog-Doc with that exact fusion in mind.

To make that possible, I developed LiteNode — a lightweight, fast Node.js framework that reflects my personal vision. It includes a built-in AST-based template engine, native Markdown handling, static asset auto-serving, environment variable support, and complete cookie management — all without external dependencies.

Aether CMS is the culmination of that entire journey — from Blog-Doc to LiteNode — and every architectural decision reflects years of real use, iteration, and planning. There's no AI on earth that could have imagined, combined, and implemented all of these pieces into a single cohesive system.

These tools helped me refine ideas, improve logic, and evaluate architectural decisions more efficiently. Without them, the process would have taken significantly longer — but every decision, every line of code, is still written by me.

I see AI as a thinking partner, not a substitute. Aether reflects my development philosophy — AI simply helped me get there faster and more confidently.