§ 01 / For developers

The WordPress plugin you don't have to apologize for.

You maintain WordPress because the client pays for WordPress — not because you enjoy shortcode soup, untyped widget props, or shipping a page-builder runtime to every visitor. Atlas is one dynamic Gutenberg block. Components are TypeScript. Pages compile to JSON manifests in your repo. The plugin renders server-side; the browser receives HTML.

Get the plugin See how it works
§ 02 / Where it hurts

Where the current dev experience hurts.

Four pains filed under "the cost of doing WordPress." Atlas moves authoring out of the database.

  1. 01

    PHP shortcode soup.

    Custom layouts live as nested shortcodes or serialized blocks inside post_content. Not reviewable, not portable across themes. You can't grep a database column the way you grep a repo.

    § authoring lives in the database
  2. 02

    No types on widget props.

    Block attributes are untyped JSON. ACF field groups are runtime structures. A renamed field silently empties pages until someone notices in production. No compiler stands between you and a broken render.

    § no compiler, no contract
  3. 03

    Page-builder JS ships to visitors.

    Elementor, Divi, and friends bundle the editor runtime into the front-end. A small page drags a heavy runtime before the hero paints. Caching papers over the symptom — the payload is still there on first load.

    § editor runtime in production
  4. 04

    Custom blocks are their own project.

    Stand up @wordpress/scripts, wire webpack, write JSX and PHP twice. Every site, fresh setup before the first line of feature code.

    § webpack before features
§ 03 / What Atlas gives you

What Atlas gives you.

Four guarantees you do not get from any other builder shipping inside WordPress today. Each one is a property of the architecture, not a feature you can lose to a roadmap pivot.

§ 04 / Three views

The same content, in three views.

A component you wrote. The manifest the compiler emitted. The HTML the plugin rendered. Same content end-to-end.

FeatureRow.tsx TSX 
type Props = {
  heading: string;
  items: { title: string; body: string }[];
};

export const FeatureRow = ({ heading, items }: Props) => (
  <section class="feature-row">
    <h2>{heading}</h2>
    <ul>
      {items.map(i => (
        <li>
          <h3>{i.title}</h3>
          <p>{i.body}</p>
        </li>
      ))}'
    </ul>
  </section>
);
page.manifest.json JSON 
{
  "type": "FeatureRow",
  "props": {
    "heading": "Why Atlas",
    "items": [
      { "title": "Types", "body": "…" },
      { "title": "Git",   "body": "…" }
    ]
  },
  "island": false
}
rendered.html HTML 
<section class="feature-row">
  <h2>Why Atlas</h2>
  <ul>
    <li><h3>Types</h3><p>…</p></li>
    <li><h3>Git</h3><p>…</p></li>
  </ul>
</section>
<!-- 0 bytes of JS -->

§ Same component in, same HTML out, every render. The manifest is the contract.

§ 05 / What you keep

What you keep.

Atlas is one block. The rest of WordPress works the way it has for twenty years.

WORDPRESS RUNTIME wp-config.php 
// hooks fire as they always have
add_filter('the_content', …);
do_action('wp_enqueue_scripts');
register_post_type('review', …);

// theme template hierarchy untouched
get_template_part('parts/hero');

// WP-CLI reads posts as usual
$ wp post list --post_type=page
ATLAS REGISTRATION atlas.php 
// one dynamic block, one render callback
register_block_type('atlas/page', [
  'render_callback' => 'atlas_render',
]);

// that's the entire surface area
§ 06 / GPL, free

What the GPL plugin gets you, free.

GPL-2.0+. Not a free tier with a feature wall, not a trial. The thing you install is the thing you can fork, audit, and vendor.

§ 07 / Developer questions

Developer questions.

Five answers worth keeping with the page so you do not have to chase them down before you decide whether to install.

  1. What Node version do I need for authoring?

    A current LTS. Authoring is a standard TypeScript toolchain — if you can build an Astro or Next.js project, you can author Atlas components. The WordPress server doesn't need Node.

  2. Is a build pipeline required, or can I paste manifests in?

    Both. In v0.1 you can paste a JSON manifest straight into the block in the WordPress editor — fine for prototypes. The TypeScript flow is what you wire into CI for real sites.

  3. Can I self-host the compiler?

    Yes. The compiler is a small Node program — run it locally, in CI, or on your own box. The hosted compiler exists so you don't have to, not because it's the only path.

  4. Does Atlas play with my existing CI?

    It's a Node build step that emits JSON. Run it in GitHub Actions, GitLab CI, Buildkite, or a Makefile. Deployment is whatever moves static files to your install today.

  5. How does this compare to headless WordPress or other builders?

    Atlas keeps WordPress as the rendering surface — no decoupled front-end, no separate Node app, no theme replacement. See the Elementor alternative and headless WordPress alternative pages for head-to-head framing.

§ 08 / Install it, read the source

Install it. Read the source.

The GPL plugin is free forever. Pull it down, point it at a manifest, see the rendered HTML on a real site before deciding anything else.

Get the plugin See pricing

One block. One plugin. Endless possibilities.