Self-Describing Content

Atomies
knows how
to be read.

A template travels with content the way a stylesheet travels with a document. Drop one in like a font. No prior agreement on formats, frameworks, or rendering standards required.

Open Demo → Read the Concept
Scroll to explore
4
System Layers
5
Host Views
∞
Content Formats
Concept

The rendering
contract travels
with the content.

The web standardized rendering globally because bandwidth was scarce. You couldn't ship a renderer with every document when doing so cost megabytes. You can now. Atomies is the architecture that reflects that reality.

01
One contract: render(data, el)
Templates are encapsulated and composable — without a shared framework. The host calls render(data, el) uniformly, regardless of what's inside. That's it. That's the contract.
02
Content addresses its own renderer
A bundle carries hash references to its parser and template. The network resolves them on demand. The same template referenced by a thousand posts is fetched once and cached. It cannot change — a hash is permanent.
03
No format mandate
Content can be JSON, Markdown, TOML, a custom DSL, binary. The envelope doesn't inspect or constrain it. Write your parser, write your template, publish them. Your format now works everywhere your content goes.
04
Always something visible
At worst, content is raw. At best, it's exactly what the author intended. Parser fails? Raw text. Template fails? Default styling. Neither fails? Perfect render. The system degrades gracefully at every step.
The shift is from "everyone agrees on what a document is" to "a document knows what it is." The network does not need to know. The runtime does not need to know in advance.
Architecture

Four layers.
None aware of each other.

Each layer is independently replaceable. The shell doesn't know what's inside the element it's moving. The template doesn't know what host view is rendering it. The engine doesn't care what either of them do.

01 · CONTENT
Content
Raw data in any encoding. The envelope holds it but never inspects it.
JSON
Markdown
Binary / DSL
→
02 · PARSER
Parser
Transforms raw content into structured data. Resolved by hash from the network.
parse(raw) → data
Hash-addressed
Any language
→
03 · TEMPLATE
Template
Renders structured data into a display element. Owns its styles and interaction.
render(data, el)
Encapsulated
Interactive
→
04 · SHELL
Shell
Host-level operations on the container element. Knows nothing about its contents.
Move / Resize
Rotate / Select
Placement state
Reference Implementation

The same content.
Five host views.

The demo renders seven content items — notes, checklists, metrics, logs, embeds — across five completely different host layouts. Canvas, gallery, timeline, dashboard, kanban. Same engine. Same templates. Same data. Only the chrome changes.

Open Demo →
Served locally · No build step · Plain HTML + ES modules
localhost:8945
◎ Canvas
▦ Gallery
▬ Timeline
⊞ Dashboard
☰ Kanban
tpl:note · arch-note
Template Architecture
Shell handles transforms. Templates render content.
tpl:checklist · mvp-checklist
MVP Scope
Registry, shell, JSON loading…
tpl:metric · tpl-count
5
Templates registered
tpl:log · bootstrap-log
System bootstrapped
Shell, registry, and content store decoupled.
System Properties

Designed properties,
not emergent ones.

Security, portability, and framework independence aren't goals Atomies works toward — they're structural consequences of how the system is built. Each property follows from the architecture rather than requiring additional work.

⬡
Security
The browser sandbox is the security model. Atomies content is strictly less privileged than a webpage — confined to a single container element with no top-level DOM access, no navigation, no permission surface.

Hash-based addressing means a blocklist entry never goes stale. A blacklisted hash refers to exactly one artifact, forever. Community-maintained trust lists propagate through the same network as templates.
Sandbox + hash trust · Permanent blocklists
◈
Portability
Atomies is not a JavaScript system. It is a protocol whose first implementation uses JavaScript because browsers are everywhere. The protocol itself is language-neutral.

A Godot implementation, a C + GUI library implementation, a Fudgel implementation — they all resolve the same hashes, execute the same rendering contract, serve the same content. The bundle format doesn't change. The content doesn't change. Only the runtime does.
Language-neutral protocol · Browser as bootstrap
⬕
Framework Independence
Framework churn persists because every framework competes to be the global rendering contract. Atomies removes the global contract entirely.

The host handles layout chrome. The template handles content rendering. A bad framework choice inside one template affects one template. The blast radius shrinks from the entire application to a single content card. Templates from different years, different authors, different approaches coexist without conflict.
Local decisions · No migration · No version matrix
Resolution Model

Five steps.
Deterministic. Always.

01
Receive bundle
Extract content, parser hash, template hash from the envelope.
02
Resolve parser
Check local cache. If missing, pull from network by hash, cache permanently. Fall back to runtime default if no hash declared.
03
Parse content
Execute parser against raw content. Produce structured data. If parsing fails, display raw inline.
04
Resolve template
Same path as parser resolution. Cache on first retrieval, instant on every subsequent reference.
05
Mount
Call render(data, element). The template fills the container. The host manages the container's position and geometry from the outside.
Degradation Table
Parser missing Raw content displayed inline
Content visible, unformatted
Parser fails Raw content displayed inline
Content visible, unformatted
Template missing Default template applied
Structured, unstyled
Template fails Default template applied
Structured, unstyled
Both fail Raw bytes as text
Always something visible