The Headless Dilemma
The CMS world is divided into two camps: traditional monolithic systems that tightly couple content and presentation, and headless systems that provide APIs but no rendering at all.
Both approaches have significant drawbacks:
Monolithic CMS
- Tightly coupled to one frontend
- Difficult to use content elsewhere
- Server-rendered, slower page loads
- Complex caching requirements
- Scaling is expensive
Headless CMS
- API-only, no rendering
- Frontend is your problem
- Every page needs JS to render
- Poor SEO without workarounds
- Two systems to maintain
The Traditional Trade-off
Traditional CMS platforms force you to choose: either you get an integrated authoring experience with tightly coupled presentation, or you get API flexibility but lose the integrated experience.
// Typical headless CMS setup
// 1. Content team creates content in CMS
// 2. Developer builds separate frontend app
// 3. Frontend fetches content via API
// 4. Every page load = API call = latency
// React component that needs runtime data
function BlogPost({ slug }) {
const [post, setPost] = useState(null);
useEffect(() => {
// API call on every page view
fetch(`https://cms.example.com/api/posts/${slug}`)
.then(res => res.json())
.then(setPost);
}, [slug]);
if (!post) return <Loading />; // User sees spinner
return <Article {...post} />;
}This pattern means every visitor makes API calls, every page load has latency, and you're paying for API compute on every request.
Aether's Hybrid Approach
Aether eliminates this trade-off. It's static-first with optional dynamic islands - you get the performance of static sites, the flexibility of headless APIs, and dynamic interactivity where you need it.
Static-First, Not Static-Only
Aether generates static HTML at build time for instant page loads and perfect SEO. But when you need dynamic content - comments, user-specific data, real-time updates - you can add dynamic islands without rebuilding the static shell.
Static-First Architecture
When you publish content in Aether, it generates static HTML, CSS, and JavaScript that can be served from any CDN. No server-side rendering required for page views.
# Build static files
$ aether build
Building site: my-blog
✓ Compiled 42 pages
✓ Generated 156 static HTML files
✓ Optimized 89 images
✓ Created sitemap.xml
✓ Generated RSS feeds
Output: dist/
index.html # Instant load, no JS required
articles/
my-first-post.html # Complete HTML, perfect SEO
another-post.html
assets/
styles.css # Optimized, fingerprinted
main.js # Only for interactivityBenefits of Static-First
| Aspect | Server-Rendered | Static-First (Aether) |
|---|---|---|
| Page Load | 200-500ms (server processing) | 20-50ms (CDN edge) |
| Scalability | Add servers as traffic grows | Infinite (CDN handles it) |
| Cost at Scale | $100s-1000s/month in compute | $5-25/month (just storage + CDN) |
| SEO | Good (full HTML response) | Perfect (pre-rendered) |
| Reliability | Depends on server uptime | 99.99% (CDN redundancy) |
Full REST & GraphQL APIs
When you need to build mobile apps, integrate with other systems, or create custom frontends, Aether provides complete APIs for all content.
# List articles
GET /api/v1/articles
GET /api/v1/articles?filter[category]=technology&sort=-published
# Get single article
GET /api/v1/articles/my-first-post
# Include relationships
GET /api/v1/articles/my-first-post?include=author,tags,category
# Create content (authenticated)
POST /api/v1/articles
{
"data": {
"type": "article",
"attributes": {
"title": "New Article",
"body": "Content here..."
}
}
}# Fetch exactly what you need
query {
articles(first: 10, where: { category: "technology" }) {
edges {
node {
title
slug
excerpt
publishedAt
author {
name
avatar
}
tags {
name
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}Dynamic Islands
Sometimes you need dynamic content within a static page - comments, user-specific recommendations, real-time data. Aether's dynamic islands let you add interactivity without sacrificing static performance.
<!-- Static page shell loads instantly -->
<article>
<h1>{{ article.title }}</h1>
<div class="content">{{ article.body }}</div>
<!-- Dynamic island for comments -->
<aether-island
component="comments"
article-id="{{ article.id }}"
loading="lazy">
<!-- Placeholder while loading -->
<p>Loading comments...</p>
</aether-island>
<!-- Dynamic island for related content -->
<aether-island
component="related-articles"
tags="{{ article.tags | json }}"
loading="visible">
</aether-island>
</article>The Simplex Advantage
Aether's hybrid architecture is possible because of Simplex's unique capabilities:
1. Content-Addressed Builds
Simplex identifies code and content by hash. When you publish, Aether knows exactly what changed and only rebuilds affected pages. A single article edit doesn't trigger a full site rebuild.
# Edit one article, rebuild only what's affected
$ aether build --incremental
Analyzing changes...
Changed: articles/my-post.md
Affected pages:
✓ articles/my-post.html (content changed)
✓ index.html (lists this article)
✓ feed.xml (includes this article)
Skipped: 153 unchanged pages
Build time: 0.8s # vs 45s for full rebuild2. Resumable Computation
Simplex computations can checkpoint and resume. Large builds can be paused and continued, and build failures don't lose progress.
3. Distributed Generation
For large sites, Aether can distribute page generation across multiple nodes. Generate 10,000 pages in parallel across a Simplex swarm.
Type-Safe Frontend Integration
Aether generates TypeScript types from your content schema, giving you full type safety in your frontend code.
// Auto-generated from your content schema
export interface Article {
id: string;
title: string;
slug: string;
body: RichText;
author: Reference<User>;
category: Reference<Category>;
tags: Reference<Tag>[];
publishedAt: Date;
status: 'draft' | 'published' | 'archived';
}
// Use in your React/Vue/Svelte app
const article: Article = await aether.getArticle(slug);
console.log(article.title); // Full autocomplete!Best of All Worlds
Aether gives you: the performance of static sites, the flexibility of headless APIs, the integrated experience of traditional CMS, and dynamic interactivity where you need it. All without the complexity of maintaining multiple systems.