GoPress reorganizes the proven building blocks of a traditional CMS — content models, themes, plugins, and admin workflows — around the Go runtime and Go engineering ecosystem. It provides a unified content model, data-driven admin CRUD, a theme template engine, hook/filter extension points, REST APIs, a protocol-neutral Agent execution layer, an optional remote MCP server, SEO primitives, multi-level caching, media variants, and site-level configuration.
A modern CMS framework written in Golang, inspired by the best ideas of WordPress and rebuilt for performance, extensibility, and clean deployment.
Звёзды
22
Инструменты
—
Аптайм
—
GoPress is not a line-by-line rewrite of WordPress, and it is not a statement against PHP. It focuses on a narrower engineering need: keeping the editorial experience and extension model of a CMS while gaining the deployment, concurrency, observability, and long-term maintenance advantages of Go.
Project Status
GoPress is currently in beta. The core content model, admin CMS, theme engine, plugin mechanism, SEO layer, cache path, media pipeline, and bundled example themes are usable, but the project still needs more production validation, benchmark coverage, migration guides, and security review before a stable public release.
If you plan to use GoPress in production, start with internal sites, company websites, documentation sites, or content-driven applications, then validate your traffic profile, editorial workflow, backup strategy, and deployment model.
Why GoPress?
The CMS ecosystem has proven the long-term value of the “content model + theme + plugin + admin” abstraction. GoPress keeps that product shape while using Go’s single-service deployment model, goroutine concurrency, static typing, and standardized toolchain to reduce operational complexity for self-hosted CMS projects.
The comparison below is not meant to rank technology stacks. It describes the design trade-offs GoPress makes:
Area
WordPress (PHP)
GoPress (Go)
Runtime model
PHP-FPM / web server stack, centered on request lifecycle execution
Long-running Go service process, suitable for in-memory registries and workers
Extension model
Mature theme/plugin ecosystem with flexible runtime loading
Go interfaces and hook registration, emphasizing type safety and maintainability
Cache strategy
Usually enhanced through plugins, object caches, and reverse proxies
Built-in memory, Redis, and page-cache paths with graceful fallback
Scheduled work
Commonly handled through WP-Cron or system cron
Process-owned scheduler and worker pool
Deployment shape
Web server, PHP runtime, database, and optional cache services
Compiled Go service plus database and optional Redis
Architecture At A Glance
GoPress brings public delivery, admin workflows, REST / OpenAPI, content services, and governance into one compiled Go runtime. Themes contribute presentation and plugins contribute capabilities through the generic core extension contract rather than direct runtime coupling, while PostgreSQL, optional Redis, media assets, workers, and scheduling form the runtime foundation.
Design Principles
Content first — a unified Content + Meta model supports posts, contact messages, and theme-declared custom content types.
Themes stay separate from the engine — themes render output; the engine owns routing, querying, SEO, media, admin behavior, and shared infrastructure.
Plugins extend through interfaces — plugins register capabilities through Go interfaces, hooks, and filters instead of hidden runtime coupling.
Cache is a core capability — memory cache, Redis cache, and page cache are part of the core path, with graceful degradation when Redis is unavailable.
SEO is built in — URL rewriting, permalinks, canonical tags, sitemap generation, meta output, and redirects are handled at the core layer.
API first — registered content types can expose REST endpoints and Swagger / OpenAPI documentation.
Instance isolation — table prefixes and site-level configuration allow multiple instances to share infrastructure while keeping data boundaries clear.
Agent access is governed, not bypassed — Agent tools reuse Core domain services and require credential scopes, current RBAC, ownership checks, risk policy, idempotency, and audit.
Theme And Admin UI Preview
GoPress ships with a practical admin CMS and a set of production-oriented example themes. The previews below show the direction of the bundled UI: theme-specific visual systems on the public side, and a focused content-management workspace on the admin side.
Admin UI
The first-run installer guides database connection, site bootstrap, and admin account creation before the CMS opens.
Redis 7+ (optional; GoPress falls back to memory-only cache when Redis is unavailable)
cwebp (optional; used for WebP variants; missing binaries fall back to JPG/PNG variants)
Install and Run
GoPress ships with a small orchestrator CLI named gopress. It scans themes/ and plugins/ at startup, regenerates the autoload package, and runs the server. You never have to hand-edit imports when adding a theme or plugin — drop the folder in, restart with gopress serve, and it is picked up automatically.
The fastest way to try GoPress is the local build — no global install required.
# Clone the repository
git clone https://github.com/0xmattg/go-press.git
cd go-press
# Download dependencies
go mod download
# Build the gopress CLI into ./build/ (no global install needed)
make gopress
# Start the server. First run opens the web installer.
./build/gopress serve
# Or start with an existing site config (any flag is forwarded to cmd/server)
./build/gopress serve -config sites/localhost/config.toml
# Produce a single production binary (autoload baked in at build time)
./build/gopress build # -> build/gopress-server
./build/gopress build -o ./myserver # custom output path
make help lists all Make targets. ./build/gopress help lists all CLI subcommands.
Optional: install globally
If you plan to use GoPress regularly, install the CLI onto $PATH so you can drop the ./build/ prefix:
make install # installs gopress to $GOBIN (or $GOPATH/bin)
gopress serve # works from any directory after install
Building on a 1c1g VM?go build parallelizes across all cores and can be OOM-killed on small VPS instances. Prefix with GOFLAGS="-p=1 -v" to force serial compilation, e.g. GOFLAGS="-p=1 -v" make gopress. See installation guide for details.
After startup:
URL
Purpose
http://localhost:8080
Public site
http://localhost:8080/admin
Admin CMS
http://localhost:8080/swagger/index.html
API documentation
http://localhost:8080/api/v1/content
REST API
http://localhost:8080/mcp
Remote MCP endpoint, only while the optional gopress-mcp plugin is active
Generated Swagger Go package imported by the server entry point
Regenerate docs with:
go run ./cmd/gendoc/
Feature Overview
Public Accounts and Identity
Provider-neutral account core — nullable email/password credentials, external identity bindings keyed by (provider, issuer, subject), policy-controlled registration and linking, and database-backed revocable sessions.
Admin-controlled registration policy — independent switches for public registration, external login, external auto-registration, account linking, and a privilege-limited default role.
Plugin protocol boundary — identity plugins verify OIDC, wallet signatures, or future protocols, then pass only VerifiedIdentity assertions to core.
Theme-ready helpers — currentUser, isLoggedIn, loginURL, logoutURL, and loginProviders let themes render account UI without knowing which provider plugin is active.
Immediate account shutdown — disabling an account rejects existing admin
tokens and public sessions on their next request instead of waiting for token
expiry.
See Public Authentication for the core model, Google and MetaMask setup, plugin contracts, and theme integration.
Public Content Submission
Declarative policy — theme-defined content types may opt into frontend
authoring with allowed roles, default review status, and owner update/delete
controls in theme.toml.
Core-enforced writes — active-account checks, type-scoped RBAC, ownership,
input limits, global slug uniqueness, sanitization, and per-user rate limits
remain in Core while themes own routes and presentation.
Safe lifecycle — active-theme capabilities are granted by handle and
withdrawn on theme changes without disturbing pre-existing RBAC rules.
See Public Content Submission for the policy, service contract, moderation states, and route security checklist.
Authenticated Comments
Core-owned comment domain — comments remain available across theme switches and can target any registered content type that declares comments support.
Registered-user participation — active signed-in users with comment.create can post top-level comments and one level of direct replies; anonymous submissions are not accepted.
Moderated visibility and safety — new comments default to pending, trusted server policy may approve immediately, approved comments are public, authors can see their own pending comments, and core enforces body limits, per-user rate limits, published-target checks, and per-content open/closed status.
Owner-scoped review — content owners may review replies on their own content only after server-side ownership and update_own checks; global moderation remains protected by comment.moderate.
Theme-neutral account integration — themes consume safe comment projections, current-user authorization, and own comment activity through core contracts without importing a specific identity plugin.
See Comments and Moderation for the data model, theme contract, moderation flow, security rules, and extension points.
Agent and MCP (Safe Write Beta)
Protocol-neutral Core — core/agent owns the Tool Registry, Principal refresh, credential scopes, RBAC and ownership authorization, risk policy, schema validation, bounded execution, idempotency, and mandatory audit without importing MCP.
Optional official adapter — the disabled-by-default gopress-mcp plugin exposes a stateless Streamable HTTP endpoint at /mcp through the official Go SDK, supporting protocol 2026-07-28 and a 2025-11-25 compatibility path.
Read-only by default — six read tools cover safe site metadata, content types, content, taxonomy, and media metadata. Tool discovery is filtered per credential and privately cached for 30 seconds.
Explicit Safe Write — six content/media write tools require safe_write, an individual Tool switch, a matching token scope, current Core RBAC, and ownership where applicable. Every write has an idempotency key; updates use optimistic timestamps; publish and trash require explicit confirmation.
Short-lived credentials and audit — administrator-issued Bearer tokens are audience-bound, valid for at most 90 days, stored only as digests, displayed once, and immediately revocable. Audit stores metadata and digests rather than tokens or argument values.
Accurate Beta boundary — OAuth 2.1 browser authorization, Resources, Prompts, Tasks, and MCP Apps are later phases and are not part of the current server.
See the independent Agent and MCP guide for
design and implementation details. For endpoint setup, scopes, Tool inputs,
curl checks, and troubleshooting, use the
GoPress MCP plugin guide.
Engine Core
Unified content model — Content + ContentMeta + ContentType registry; core keeps post, page, and contact_message, while themes declare custom types in theme.toml.
Pending editorial workflow — the shared content model and admin editor recognize a protected pending review state in addition to draft, published, archived, and trash lifecycle states.
Standalone pages — a built-in page type for About/Terms/Privacy-style pages: root-level permalinks (/about), hierarchical parents, per-page theme templates, and an iframe-allowlisted embed field. See Standalone Pages.
Config-driven content routing — theme.tomlrewrite_slug and optional templates = { archive = "...", single = "..." } drive archive URLs, detail URLs, sitemap entries, admin permalinks, and dynamic template resolution. product, service, and showcase are examples, not framework assumptions.
Chainable content queries — for example: ContentQuery.Type("product").Published().Taxonomy("category", "hepa").Paginate(1, 20).
Scoped taxonomy core — generic request scopes cover term lookup, trees, reference counts, content relationships, and mutation validation. Plugins can provide per-language or tenant-specific category/tag identities without adding language concepts to core.
Guarded taxonomy commands — create, update, delete, parent selection, scoped slug uniqueness, and relationship writes share one transactional command service with registered-type and scope validation.
Hook event bus — AddAction / DoAction / AddFilter / ApplyFilter, with removable handles for clean plugin deactivation.
Multi-level cache — L1 memory cache, optional L2 Redis, graceful fallback, and page-cache middleware for sub-millisecond cache hits.
Worker pool — goroutine worker pool plus cron-style scheduling.
Core i18n — go-i18n with three-level fallback: database override, locale file, then message ID.
URL and SEO
Shared site metadata — admin-managed site_name, site_description, and site_timezone are used across themes; publish times are entered and displayed in the site timezone while stored as UTC.
SEOBuilder — home, archive, and single pages generate meta descriptions, canonical links, Open Graph tags, JSON-LD, and crawler-friendly favicon links.
seoHeadFor helper — reflection-based and safe for both gin.H and custom structs.
Per-content SEO overrides — the bundled seo-extras plugin adds Yoast-style fields for title, description, Open Graph image, and robots.
Multilingual sitemap support — SitemapGenerator.AddTransformer() and taxonomy SEO filters let the multilingual plugin contribute content and translated-term hreflang alternates.
Site-scoped public artifacts — admin-generated sitemap files and favicon assets are written under sites/{host}/public/, keeping multi-site deployments isolated.
Redirect manager — database-backed 301/302 redirects with in-memory lookup and hit counts.
Admin CMS
Data-driven CRUD — admin list/edit screens are generated from the registered ContentType definitions.
Theme-declared content models — theme.toml drives admin navigation, CRUD, REST API exposure, rewrite rules, template mapping, and menu icons.
Standalone pages — a dedicated Pages screen for hierarchical, root-level pages, with a page-template picker and a per-page embed-code field for third-party iframes.
RBAC — admin, editor, author, and subscriber roles enforced throughout the admin surface.
List screen options and pagination — content lists support dynamic column visibility, title search, date/taxonomy filters, and server-side pagination.
Comment moderation — filterable, server-paginated review queues support pending, approved, spam, and trash states, with direct links to the related content or parent comment and comment.moderate RBAC enforcement.
Mail settings and notifications — dedicated SMTP settings page, go-mail SMTP driver with Go stdlib option, site-level config.toml storage for mail.mail_key, test emails, Gmail-friendly 587 + STARTTLS setup, and a switch for new contact-message notifications.
Drag sorting and rich text — Quill 2.0 editor, media picker, and HTML5 drag-and-drop ordering.
Admin extension points — hooks such as admin.HookContentListTabs, admin.HookTaxonomyListTabs, admin.HookContentPermalinkPrefix, admin.content_form.fields, admin.content.saved, and mail.message.
Themes and Plugins
BaseTheme runtime — embed it to get config-driven URL resolution, dynamic archive/detail rendering, WordPress-style fallback hierarchy, and automatic SEO integration.
multilang — WPML-style content plus optional Category/Tag translation, menu and site-setting translation, canonical language-prefixed routing, and language-aware redirects.
seo-extras — Yoast-style per-content SEO overrides for title, description, Open Graph image, and robots.
code-snippets — WPCode-style site-level injection for end of <head>, start of <body>, and before </body>.
gopress-mcp — Read-only-by-default remote MCP adapter for Core Agent tools, with controlled Safe Write, short-lived credentials, diagnostics, and audit. Disabled by default. See GoPress MCP.
google-identity — Google OIDC login and registration for Gmail and Google Workspace accounts, built on the provider-neutral public-auth core.
metamask-identity — MetaMask browser-extension login and registration through EIP-4361 Sign-In with Ethereum and one-time server challenges.
commerce — Opt-in e-commerce module (WooCommerce-like): product catalog, guest/account cart, single-transaction checkout, order state machine, inventory reservation with row locks, a medium-agnostic payment-gateway contract, and a built-in offline bank-transfer gateway. Disabled by default. See docs/guide/en/commerce/overview.md.
commerce-paypal — PayPal (Orders v2) satellite gateway: sandbox/live, buyer-return capture, webhook signature verification, and refunds. Depends only on the core/commerce contracts (no plugin→plugin dependency).
commerce-usdt — USDT (ERC-20) crypto satellite gateway: pull-based confirmation through a per-order HD-derived address, verified Ethereum RPC identity/logs, atomic scan cursors, chain-time expiry, and idempotent settlement. Watch-only xpub—the server holds no spend authority. The implementation is EVM-extensible; Ethereum is currently supported. Depends only on the core/commerce contracts.
These are current architecture targets. Reproducible benchmark scripts, test environment notes, and public benchmark reports still need to be added before a stable release.
Списка инструментов пока нет. У удалённых серверов он появляется после первой проверки состояния.
FAQ
Вопросы
Как установить Go Press?
Скопируйте на этой странице конфигурацию stdio для Cursor, Claude Desktop, Claude Code или VS Code. Она использует установку издателя, а не прокси PlugMCP.
Нужен ли API-ключ для Go Press?
В этой записи не указано обязательных переменных окружения.
Какой транспорт использует Go Press?
Go Press работает локально через stdio.
Когда Go Press проверялся в последний раз?
Последняя проверка: 2026-11-14. A modern CMS framework written in Golang, inspired by the best ideas of WordPress and rebuilt for performance, extensibility, and clean deployment.