Core
Go-first CMS runtime
A modern CMS core built for performance, typed contracts, and explicit lifecycle control.
WordPress-style extensibility, rebuilt for Go
A Go-powered CMS
with compiled plugins.
BlitzPress keeps the plugin mindset teams already understand, then rebuilds the platform around typed contracts, runtime-loaded extensions, and a cleaner system model.
Scroll
Peel Back the Layers
Click the layers to reveal the underlying technology stack.
Layer 1 • The Presentation Layer
SolidJS Admin UI
Dynamic frontend that composes UI widgets from both core and loaded plugins without requiring a build step.
Click to peel back
import { render } from "solid-js/web";
import { PluginRegistry } from "@blitzpress/sdk";
// Load plugin modules at runtime
PluginRegistry.loadAll();
render(() => <AdminApp />, document.getElementById("app"));Layer 2 • The Extension Layer
Compiled Plugins (.so)
Go plugins loaded at runtime. They mount routes, add database models, and hook into core events natively.
Click to peel back
package main
import "github.com/blitzpress/sdk"
// Plugin entry point
func InitPlugin(api sdk.API) {
api.RegisterRoute("/custom", myHandler)
api.AddAdminWidget("dashboard", MyWidget)
}Layer 3 • The Foundation
Go Core Binary
High-performance Go server managing the database, authentication, and the plugin lifecycle.
Click to peel back
package main
import "github.com/blitzpress/core"
func main() {
app := core.New()
// Discover and load .so files
app.LoadPlugins("./plugins")
app.Start(":8080")
}The Bare Metal
Underneath it all, BlitzPress is just clean Go interfaces and simple SolidJS primitives. No magic, just solid engineering.
Keep the flexibility.
Replace the assumptions.
Traditional CMS platforms proved the value of hooks and ecosystems. BlitzPress keeps that insight while modernizing the runtime, extension boundaries, and admin model.
Reason
Keep extensibility, replace the old runtime
BlitzPress preserves the plugin mindset that made WordPress powerful while moving the platform to Go and typed interfaces.
Difference
A CMS product and a plugin platform
The value is not only content management. It is the system for building structured CMS extensions with cleaner contracts.
Audience
Made for teams that build on top of their CMS
Use it when you need admin workflows, extension points, and a system that developers can reason about.
Architecture Preview
The core binary, plugin runtime, embedded admin, and shared frontend modules fit together cleanly. Interact with the map below to see the data flow.
Click a component to dive deeper into the architecture.
1
Core binary
Hosts the API, database layer, plugin registry, hooks, and embedded admin app.
2
Plugin runtime
Loads compatible plugins, validates manifests, mounts routes, and exposes extension surfaces.
3
Shared frontend modules
Runtime-loaded admin modules register pages, widgets, and settings UI without a core rebuild.
4
Composable admin experience
Editors and operators see one coherent CMS while plugins extend the product surface behind the scenes.
Four reasons it feels different.
The point is not one isolated feature. It is the way the core, plugin runtime, frontend extensibility, and developer workflow reinforce each other.
Plugins
Compiled plugin architecture
Manifest-driven `.so` plugins mount routes, assets, settings, and hooks without rebuilding the core.
Frontend
Dynamic SolidJS admin
Plugin frontends load at runtime through shared modules and a registrar-based extension model.
DX
Monorepo with real workflows
Build scripts, hot reload, example plugins, and a manager CLI make the platform practical to adopt.
Start with the product story.
BlitzPress makes the most sense when you see how the CMS surface, plugin runtime, and developer workflow connect into one platform.