# Sophia Stack X
Every page of this site as Markdown. Each page also has its own copy at
/index.md.
---
# Sophia Stack X
Source: https://sophiastack.sophiaxt.com/
# The whole website platform, _in one file._
One program runs your entire website: the CMS, the web server and the build system. Built for people and for AI agents.
[Install](https://sophiastack.sophiaxt.com/install) [Try it now](https://demo.sophiastack.sophiaxt.com/demo/start)

Publish: **Plain files, one-click rollback**
Agents: **MCP server built in**
Server: **One program, one database**
Start here
## Two ways in.
Pick the one that sounds like you. Both run the same program.
### [Build a website](https://demo.sophiastack.sophiaxt.com/demo/start)
For owners and small teams. Try a private bakery site in the live demo for an hour, pick a template, or download the program and have a working site in about two minutes. No code needed.
Open the live demo
```
1. Open the live demo, nothing to install
2. Edit a page, publish it, roll it back
3. Or install it on your own computer or server
```
### [Build with AI](https://sophiastack.sophiaxt.com/docs/ai-agents)
For developers and agents. Every copy runs an MCP server with 55 tools, a content API, and an SDK with an OpenAPI spec and TypeScript types. An agent works in drafts, previews and rollbacks, and every call is logged.
Read the AI agent guide
```
**$** sophia mcp
MCP server on stdio, 55 tools
**$** sophia docs
the whole system as one text reference
```
New in the Studio
## Design it like a studio, not a form.
The editor is a dark canvas workspace. Every page sits on the canvas, every section has real design controls, and nothing you set can leave text unreadable.
### The whole site on one canvas
Every page laid out as an artboard. Zoom out to see them all, click one to edit it, pan with the space bar. Undo and redo cover every change.

### A library of 25 sections
Heroes, features, pricing, testimonials, calls to action, FAQ, stats, logos, contact, team and gallery. Drop one in and replace the placeholder text.

### Effects
Solid, gradient or picture backgrounds, corner radius, soft or glow shadows, frosted glass, full-screen height, and wave or curve dividers that blend into the next section.

### Motion
Fade, rise, zoom or slide in as visitors scroll. Off for people who ask for less motion, and every word stays readable without scripts.

### Theme, live
Colors, fonts, buttons and presets for the whole site, previewed on the page as you change them.

### [Nova, a new template](https://sophiastack.sophiaxt.com/templates)
A dark space look: gradient headlines, glass cards, glowing buttons and a tilted frame for screenshots. Five color presets.
See all templates

## Questions a buyer asks
**Can I build a site without writing code?** Yes. Pages are built from blocks in a visual builder with a live preview, and the look (colors, fonts, buttons) is set on a Design screen that blocks unreadable text. Booking, a newsletter, a shop and forms are switched on, not coded. See [templates](https://sophiastack.sophiaxt.com/templates) or try the [live demo](https://demo.sophiastack.sophiaxt.com/demo/start).
**Can I move my WordPress site without breaking links?** The importer reads a WordPress export file, brings over pages, posts, pictures, menus, WooCommerce products and approved comments, and makes every old address answer with a 301 redirect to its new page. It does not bring plugin shortcodes, custom post types or your old theme. [The walkthrough](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress) lists what comes over and how to check the redirects before you switch.
**Can I install templates and extensions?** Yes, from the [marketplace](https://sophiastack.sophiaxt.com/marketplace) in one click or with `sophia market-install`. Each package is reviewed by SOPHIA XT and checked against a signed catalog. Extension code runs in a sandbox with only the permissions it declares.
**What happens when something goes wrong?** Publishing checks links first, the last ten versions are kept, and any of them goes live again in one click. Backups of the database, pictures and settings are one button or `sophia backup`. A program update that does not answer within 30 seconds puts the old version back by itself.
**Why trust a new platform?** You should ask. This is version 0.1.0, made by SOPHIA XT LLC. What we can show is below: your site is plain files you can host anywhere, downloads are signed and checkable, the [changelog](https://sophiastack.sophiaxt.com/changelog) is dated, and [benchmarks](https://sophiastack.sophiaxt.com/benchmarks) were measured on one machine with the method written down. [Compare](https://sophiastack.sophiaxt.com/compare) it with WordPress, Joomla and Ghost before you decide.
## You own your site
The [license](https://sophiastack.sophiaxt.com/license) says: "What you make with it is yours: your content, your data, and the extensions, templates and sites you build." And on what happens if Sophia Stack X stops: "Your sites are published as plain HTML files, and every page also has a Markdown copy. You can serve them with any web server, and your content sits in one SQLite database file you control."
Plain terms: the published site is ordinary files, so it keeps working on any web server. The program itself is not open source, so without it you would lose the admin and updates, but not your content or your pages.
## Your AI agent can build the site.
Every copy runs an MCP server. Connect any MCP client and it works the way you do: drafts first, a preview, a check of what will change, then publish. If something is wrong, one call puts the last version back.
* Creates and edits pages as drafts
* Previews every page before it goes live
* Shows what a publish will change, then publishes
* Rolls back in one call
* Every call lands in the audit log
```
# agent: add a pricing page and publish it
$ entry_save {"site": "main", "collection": "page", "title": "Pricing"}
saved entry 18 as a draft
$ page_preview {"site": "main", "path": "/pricing"}
status 200, no errors
$ publish_preview {"site": "main"}
1 page added, 0 changed, 0 removed
$ publish {"site": "main"}
release 17 is live
$ rollback {"site": "main", "release_id": 16}
release 16 is live again
```
program to install: 1
database file: 1
tools for AI agents: 55
PHP, MySQL or Node to patch: 0
* Studio canvas
* 25 ready-made sections
* Section effects
* Scroll motion
* Undo and redo
* Nova template
* Page builder
* Online booking
* AI assistant
* Newsletter
* Visitor stats, no cookies
* Articles
* Shop
* Stripe checkout
* Discount codes
* Forms
* Events
* Comments
* Site accounts
* Email
* SEO audit
* llms.txt
* Markdown copies
* MCP server
## Ready for local businesses.
The apps a salon, clinic, contractor, shop or restaurant needs come with every copy. Switch one on and it fits the template you already use.
* Online booking with opening hours, capacity and cancel links
* An AI assistant that answers from your own pages, with your own API key
* A newsletter with confirm-by-email and one-click unsubscribe
* Pricing, team, reviews, opening hours, contact and before-and-after blocks
* Visitor stats without cookies, and email set up in a minute
```
# agent: set up online booking for the salon
$ extension_enable {"site": "main", "name": "bookings"}
bookings is on
$ entry_save {"site": "main", "collection": "service", "title": "Haircut"}
saved entry 31 as a draft
$ publish {"site": "main"}
release 18 is live
```
[Play video](https://sophiastack.sophiaxt.com/video/restaurant-inbox.mp4) 39 seconds: restaurant menus, order and booking links, search, and the inbox. The restaurant in it is a made-up sample.
## Built with Sophia Stack X.
A business that runs on it today, and the looks a new site can start from.
### [3 Point Forward](https://3pointforward.com)
A Metro Detroit studio that builds and hosts websites for small businesses for $25 a week. Its site runs on Sophia Stack X.
Visit 3pointforward.com

### [Trade](https://sophiastack.sophiaxt.com/templates)
For contractors, salons and clinics: a call button in the header, a call bar on phones and a quote form.
See all templates

### [A bakery you can edit](https://demo.sophiastack.sophiaxt.com/demo/start)
The Hearth template with a shop, a cake inquiry form and four pages. Change it, publish it, roll it back.
Try it now

### [Studio](https://sophiastack.sophiaxt.com/templates)
Portfolios and agencies: big headlines and picture-led project cards.

### [Journal](https://sophiastack.sophiaxt.com/templates)
Writers and newsletters: serif reading text, drop caps and a signup panel.

### [Glass](https://sophiastack.sophiaxt.com/templates)
Software and product sites. This site uses it.

## Built in, not bolted on.
Switch on what the site needs. No plugin store, no extra servers.
### Build pages from blocks
Layers on the left, the real page in the middle at desktop, tablet or phone width, and every setting on the right. Agents can add the same sections over MCP.

### Publish, then undo
Publishing writes the site as plain files and checks every link first. Any earlier version goes back live in one click.

### Design without code
Colors, fonts and sizes with a live preview. Unreadable text is blocked before it saves.

### Sell from the same site
Products, options, stock, discount codes, Stripe or pay later, emailed receipts, CSV export.
### Readable by AI search
Every page also exists as Markdown. The site serves llms.txt and answers Accept: text/markdown.
```
**$** curl -H 'Accept: text/markdown' https://your-site.com/pricing
# Pricing
Three plans, billed monthly...
```
## The real admin.
Screenshots of the demo site. Click through it yourself in the live demo.
### Where the site stands
What is live, what is waiting to publish, and who changed what.

### Pages from blocks
Layers, a canvas with zoom, a floating toolbar on the selected section, and an inspector for content, design, effects and motion. Undo and redo cover every change.

### Every page at once
The whole site as live thumbnails, drawn by its own template, with each page's state and address.

### Ready-made sections
25 designed sections with thumbnails. Pick one and it lands on the page with its design.

### The look, checked
Every color and size the template allows, tested for contrast, previewed at three widths.

### Versions you can return to
The last ten versions are kept. The live site is plain files, so it stays up even if the admin is down.

### Bring your old site
WordPress and WooCommerce, Joomla, or a folder of Markdown. Old addresses redirect.

### Your sign-in
Two-factor codes, recovery codes, and every signed-in device with a sign-out button.

## Secure before you touch a setting.
Written from scratch in Rust by SOPHIA XT, not a fork of another CMS. On a server it runs as its own user in a locked-down service. Extensions run in a sandbox and get only the permissions they declare.
* Two-factor sign-in and recovery codes
* Ed25519-signed packages and updates
* A one-time setup link, so nobody else can claim a new install
* An audit log of every sign-in and change
* Backups and restore built in
* Scripts only from the site itself, by content policy

## To a server in one command.
sophia deploy copies the program and your sites over ssh, sets up the service, the web server and HTTPS, and checks the new version answers. If it doesn't, the old one comes back.
* Signed updates: sophia update --latest
* Three versions and three database copies kept
* nginx, Caddy, or your own proxy
```
$ sophia deploy root@your-server --domain example.com --tls-email you@example.com
sending the program (12 MB)
unpacked version 20261110-235731
database copied to backups/pre-update-20261110-235731.db
version 20261110-235731 is answering on 127.0.0.1:8806
site answers on example.com
https://example.com is answering from here
```
## Build on it.
An extension is a folder: a manifest, templates and sandboxed JavaScript. The program checks, builds and signs it.
### Start from a working extension
An app, block, component or template, ready to open.
```
**$** sophia new app tickets
**$** sophia check extensions/tickets --json
"ok": true
```
### Permissions you can read
server.js reaches only what its manifest declares.
```
// extension.json
"permissions": ["data", "mail"]
// server.js
sx.data.create("ticket", { subject, email })
```
### A content API
Entries, menus and media, with tokens limited to the scopes you grant.
```
**$** curl -H 'Authorization: Bearer …' \
https://your-site.com/api/v1/content/page
200 OK
```
## Install it in _one line._
Linux server with systemd, as root. It checks the download, installs a locked-down service, sets up HTTPS and prints your setup link. Want to read the script first? The install guide shows how to download it, check its signature and then run it.
`curl -fsSL https://sophiastack.sophiaxt.com/download/install.sh | sudo sh -s -- --domain example.com --tls-email you@example.com`Copy
[Install guide](https://sophiastack.sophiaxt.com/install) [Try it now](https://demo.sophiastack.sophiaxt.com/demo/start)
Free for any site, including client work, under the [SOPHIA XT license](https://sophiastack.sophiaxt.com/license). Also: [compare it with WordPress, Joomla and Ghost](https://sophiastack.sophiaxt.com/compare), [benchmarks](https://sophiastack.sophiaxt.com/benchmarks), the [changelog](https://sophiastack.sophiaxt.com/changelog). Downloads for Windows, Linux (Intel and ARM) and Apple-silicon Macs are on [Install](https://sophiastack.sophiaxt.com/install).
---
# A CMS that AI agents can run over MCP | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/ai-cms
# A CMS that AI agents can run over MCP
# A CMS that AI agents can run over MCP
Many CMSs let an AI write text into a box. Sophia Stack X lets an agent do the job the way an editor does: create a page as a draft, preview it, check what a publish would change, publish, and undo it. The agent connects through MCP, the Model Context Protocol, to a server that is part of the program. There is nothing extra to install.
## Connect an agent
Locally, on the computer where the install lives:
```
sophia mcp
```
This runs an MCP server over standard input and output. Point your assistant's MCP settings at that command, run from the install's folder. In Claude Code, for example, add it to the project's `.mcp.json`.
Remotely, an agent can call `POST /api/v1/mcp` with a bearer token. A site admin makes the token under **API**, and it carries the "mcp" scope. Remote access is bound to that token's site, and tools that touch the server's own files or the whole install are left out.
## What the 55 tools cover
* **Read first:**`docs` returns the whole system as one text reference, the same text `sophia docs` prints.
* **Content:** sites, collections, entries (save, get, delete), menus and modules.
* **Media:** list, upload, and write alt text for pictures.
* **Design:**`style_get` and `style_set` change the same colors, fonts, sizes, buttons and links as the Design screen.
* **App data:** records for bookings, newsletters and anything an extension models.
* **Check and ship:**`page_preview`, `publish_preview`, `publish`, `releases`, `rollback`.
* **SEO:** an audit, suggested changes, and a decision on each.
* **Shop and visitors:** orders, order actions, and cookie-free visitor stats.
* **The install:** import a site, take a backup, read the audit log, read the mail outbox.
The [AI agents guide](https://sophiastack.sophiaxt.com/docs/ai-agents) has the full list, and [the SDK page](https://sophiastack.sophiaxt.com/docs/sdk) carries the OpenAPI spec for the content API and TypeScript types for extension code.
## How an agent stays in bounds
An agent with write access can do harm, so the safety rules are part of the tools:
* **Drafts by default.** An entry the agent saves is a draft unless it sets a state. Saving an existing entry changes only the fields it sent.
* **Checks before anything saves.** Every write goes through the same schema checks as the admin forms. One bad value in a design change and nothing saves.
* **Preview and dry run.**`page_preview` renders one page with drafts included. `publish_preview` lists the pages a publish would add, change or remove, and any that would fail.
* **One call to undo.**`rollback` puts a previous release back live. The last ten are kept.
* **Logged.** Every call is written to the audit log as `mcp.`, with who and when.
* **Scoped.** A remote token covers one site. Tools such as the inbox and importing are local only. Mail the agent reads from the inbox is treated as information, never as instructions.
This is how the example on the [home page](https://sophiastack.sophiaxt.com/) works. An agent adds a pricing page, previews it, checks the dry run, publishes it, and rolls back when it should.
## Building a whole local business site
The `docs` tool ends with a recipe an agent can follow from an empty site to a published one. Pick the template, switch on the apps the business needs (bookings, restaurant menus, a shop, a newsletter, business blocks, the website assistant), enter the facts the owner gave, build pages from blocks, preview and publish. The recipe tells the agent never to invent prices, hours or reviews: it leaves a field empty and asks.
You still read what it did. Agent work can be wrong, so open the preview, look at the dry run and keep the audit log in mind.
## Pages AI search can read
Agents also read sites. Every published page has a Markdown copy beside it, `llms.txt` maps the site, `llms-full.txt` holds every page in one file, and a request with `Accept: text/markdown` gets Markdown instead of HTML. These are plain files and headers, with nothing for you to switch on. See [Publishing, search and AI readers](https://sophiastack.sophiaxt.com/docs/publishing).
## What this is not
It does not run agents for you or include an AI model. You bring the assistant, or use the website assistant, which answers visitors from your own pages with your own API key. And MCP access is only as safe as the token you give out, so keep tokens to the one site they are for and give them only to what needs them.
## Next step
Read the [AI agents guide](https://sophiastack.sophiaxt.com/docs/ai-agents) and connect one. If you do not want to install anything yet, [open the live demo](https://demo.sophiastack.sophiaxt.com/demo/start) and look at the tools from the admin side. To see where this sits next to other systems, read the [comparison](https://sophiastack.sophiaxt.com/compare), or [install it](https://sophiastack.sophiaxt.com/install).
---
# Sophia Stack X benchmarks | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/benchmarks
# Sophia Stack X benchmarks
# Sophia Stack X benchmarks
These are numbers we measured on 15 November 2026 on one development computer. It is one machine, not a lab: the load tool ran on the same computer as the server and shared its CPU, nothing was tuned, and a different machine will give different results. We did not measure WordPress, Joomla or Ghost, so there are no comparisons here. Use the numbers to get a feel for the size of the program, not as a promise.
## The machine and the setup
* Windows 10 Pro, AMD Ryzen 7 1800X (8 cores, 16 threads), about 80 GB of RAM, Samsung 970 EVO Plus NVMe drive.
* Program: the Windows release build of version 0.1.0 (Rust, optimized, thin LTO, stripped), 32,214,528 bytes.
* Data: a copy of the site you are reading, 24 pages and about 130 MB of site files including downloads, in a data folder of its own.
* Server on `127.0.0.1:8874`, one process, no reverse proxy, no HTTPS, default settings.
* Load tool: a small Python script using asyncio and raw keep-alive HTTP/1.1 connections, run on the same computer. A script like this can be the slowest part of the test, so treat the published-page throughput as a floor for the server, not a ceiling.
## Results
| What | Result |
| --- | --- |
| Program size | 30.\. MiB (32,214,528 bytes), one file, nothing else to install |
| Cold start to first answer | 521 ms median of 7 starts (range 516 to 577 ms), measured from launching the process to the first `200` for a published page |
| Idle memory | 13.\. MiB working set, 10 seconds after start, before any request |
| Memory under load | 24 MiB peak working set with 32 connections on a published page, 28 MiB peak with 32 connections on the preview |
| Published page, 1 connection | 540 requests per second, p50 1.8 ms, p99 3.6 ms |
| Published page, 32 connections | 3,984 requests per second, p50 5.1 ms, p99 54 ms, no errors in 39,942 requests |
| Dynamic preview, 1 connection | 156 requests per second, p50 6.1 ms, p99 10.7 ms |
| Dynamic preview, 32 connections | 177 requests per second, p50 165 ms, p99 427 ms, no errors in 1,804 requests |
| Publish the docs site (24 pages) | 6.\. to 7.5 seconds, median 6.9 s, 5 runs |
Each load run lasted 10 seconds, over the same page, `/docs/concepts`.
## What the numbers mean
The **published page** is the path visitors normally use. It is a plain file served from a release folder, so one process answered several thousand requests a second with a few megabytes of extra memory. The p99 at 32 connections is probably the load script's own scheduling, since both ran on the same CPU.
The **dynamic preview** is the admin's page preview. It renders the page through the template on each request with drafts included, behind a signed-in session. It is meant for one editor, not for visitors, and the numbers show it. It is far slower than the published page because it does the work that publishing does once.
**Cold start** is the whole time from launching the process to the first answer. **Publish time** is the whole command, started from a new process, and it includes rendering every route, checking links, picture descriptions and placeholder text, and writing a new numbered release. The release for this site was about 8 MB on disk.
The preview run signed in through the install's one-click demo mode, so the session check had that extra middleware in its path.
## How to reproduce
1. Download the program from [Install](https://sophiastack.sophiaxt.com/install) and [verify it](https://sophiastack.sophiaxt.com/verify).
2. Copy a data folder to a scratch place. Use `sophia backup` or copy it while the program is stopped.
3. Time a cold start: launch `sophia serve --data --bind 127.0.0.1:8874` and poll a page until it answers `200`.
4. Time a publish: `sophia --data publish ` several times, taking the median.
5. For load, use any HTTP load tool you trust on a page of your own site, and send the site's host name in the `Host` header. Run it long enough to see steady numbers, and say what the tool and the machine were. Read memory from Task Manager or `ps`.
Run it on your own hardware and on the server you plan to use. If you get very different numbers, we want to hear about it.
Back to [Compare](https://sophiastack.sophiaxt.com/compare), the [changelog](https://sophiastack.sophiaxt.com/changelog), or [install it](https://sophiastack.sophiaxt.com/install).
---
# Blog | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/blog
# Blog
[November 11, 2026 · SOPHIA XT
## Introducing Sophia Stack X
A CMS, web server and build system in one program, with an MCP server built in so AI agents can build and run sites the careful way: draft, preview, publish, roll back.
Read more](https://sophiastack.sophiaxt.com/blog/introducing-sophia-stack-x)
---
# Introducing Sophia Stack X | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/blog/introducing-sophia-stack-x
November 11, 2026 · By SOPHIA XT
# Introducing Sophia Stack X
A CMS, web server and build system in one program, with an MCP server built in so AI agents can build and run sites the careful way: draft, preview, publish, roll back.
Running a WordPress site means running PHP, a MySQL server, a stack of plugins and a steady stream of updates for all three. We wanted the site without the upkeep, so we built Sophia Stack X: one program and one database file that hold the CMS, the web server and the build system.
## What you get
A page builder with a live preview at desktop, tablet and phone widths. Articles with this RSS feed, events, forms and moderated comments. A shop with options, stock, discount codes and Stripe checkout. Visitor accounts and email. Several sites and languages from one install. Importers for WordPress (with WooCommerce and comments) and Joomla, with old addresses redirected.
Publishing writes the site as plain files and checks every link first. The last ten versions are kept, and any of them goes back live in one click. Because the live site is plain files, it stays up even if the admin is down.
## Built for AI agents
Every copy runs an MCP server with 50 tools. An agent connected to it works the way a careful person does: it saves a draft, previews the page, checks what a publish will change, publishes, and rolls back in one call if something is wrong. Every call is written to the audit log.
Sites built with it are easy for AI to read, too. Every page has a Markdown copy, the site serves llms.txt and llms-full.txt, and a request that asks for text/markdown gets the Markdown.
## Secure from the start
It is written from scratch in Rust, not forked from another CMS. On a server it runs as its own user in a locked-down service. Sign-in has two-factor codes and recovery codes. Updates and extension packages are signed, and the installer checks every download against the signed release list before it runs anything. A new install only accepts its owner through a one-time setup link.
## Try it
Click around the [read-only demo](https://demo.sophiastack.sophiaxt.com/admin), or [install it](https://sophiastack.sophiaxt.com/install) in three steps: download one file, open it, fill in one setup page. It runs on Windows, Linux (Intel and ARM) and Apple-silicon Macs, and it is free for any site, including paid client work.
Follow along here, or subscribe to [the feed](https://sophiastack.sophiaxt.com/feed.xml) in any RSS reader.
* release
* announcement
---
# Changelog | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/changelog
# Changelog
# Changelog
What shipped, newest first. The current version is **0.1.0**. Updates are signed: on a server, `sophia update --latest` checks the release list against the SOPHIA XT release key before it changes anything. See [Install](https://sophiastack.sophiaxt.com/install).
## Next release
### 2026-11-15, not shipped yet
* **Section design.** Backgrounds (solid, gradient, image), spacing, width, visibility per block, and a page canvas overview. These are builder controls being built now and are not in the current download.
## Version 0.1.0
### 2026-11-12
* **Business apps.** Bookings with opening hours, capacity and cancel links. A newsletter with confirm-by-email and one-click unsubscribe. Business blocks: pricing, team, reviews, opening hours, contact and before-and-after. A website assistant that answers from your own pages, using your own AI key.
* **Visitor stats without cookies.**
* **Email.** Provider presets for setting up mail, an IMAP inbox, and List-Unsubscribe headers.
* **Restaurant app.** Menus with dietary filters, locations, order and booking links, and Restaurant schema for search engines.
* **Entry picker** for item fields, to link one entry to another.
* **Video block** for video files kept on the site, with byte-range file serving so playback and seeking work.
### 2026-11-11
* **SEO and sharing.** SEO tools and social share cards (Open Graph and X).
* **llms.txt** and Markdown copies of every page, for AI readers.
* **RSS feeds** for dated entries.
* **Extension and template marketplace** with a signed catalog. Every package is checked against it before it installs.
* **Design tokens for buttons and links**, set on the Design screen and checked for contrast.
* **Live demo workspaces.** A private bakery site, for an hour, that you can change, publish and roll back.
* **Templates:** Trade, Studio and Journal.
* **SDK.** An OpenAPI spec for the content API and `sophia.d.ts` TypeScript types for extension code. See [SDK](https://sophiastack.sophiaxt.com/docs/sdk).
Version 0.1.0 also includes the earlier work: the page builder, publishing with rollback, WordPress and Joomla import, shop, forms, comments, accounts, two-step sign-in, backups, signed updates and the MCP server.
## Support policy
Sophia Stack X is self-hosted, so you run it. That means:
* **You run the server.** You install it, you keep the machine and its backups in order, and you choose when to update. SOPHIA XT does not host your site or have access to it. The program sends no content or data to SOPHIA XT and contacts the download site only when you ask it to check for an update.
* **Updates are signed.** Every release is on a list signed with the SOPHIA XT release key, and `sophia update --latest` refuses anything that does not match. See [Verify a download](https://sophiastack.sophiaxt.com/verify).
* **Security reports.** If you find a security problem, tell SOPHIA XT LLC privately through [sophiaxt.com](https://sophiaxt.com) before you publish it, with enough detail to reproduce it. SOPHIA XT LLC will look at it.
* **No warranty.** The software comes without warranty, as the [license](https://sophiastack.sophiaxt.com/license) says. For other terms, such as a source review, contact SOPHIA XT LLC through sophiaxt.com.
See also [Compare](https://sophiastack.sophiaxt.com/compare), [Benchmarks](https://sophiastack.sophiaxt.com/benchmarks) and the [license](https://sophiastack.sophiaxt.com/license).
---
# Sophia Stack X compared with WordPress, Joomla and Ghost | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/compare
# Sophia Stack X compared with WordPress, Joomla and Ghost
# Sophia Stack X compared with WordPress, Joomla and Ghost
WordPress, Joomla and Ghost are mature, widely used and free to run. Sophia Stack X is new (version 0.1.0). This page says where it works differently and where the others are the better choice. It sticks to design differences we can state from each project's own documentation. It has no speed or market-share claims about other products, because we did not measure them. If you spot an error, tell us and we will fix it.
## What you install
| | Sophia Stack X | WordPress | Joomla | Ghost |
| --- | --- | --- | --- | --- |
| Written in | Rust | PHP | PHP | Node.js |
| Runs on | One program file | PHP with a web server | PHP with a web server | Node.js with a web server |
| Database | One SQLite file, made for you | MySQL or MariaDB | MySQL, MariaDB or PostgreSQL | MySQL in production |
| Install | Open the file, or one command on a Linux server | Packaged by most hosts, or a manual install | Packaged by many hosts, or a manual install | Ghost(Pro) hosting, or the Ghost CLI on a server |
| Source | Not open source. Free to use, including client work | Open source (GPL) | Open source (GPL) | Open source (MIT) |
Open source is a real advantage for the other three: you can read the code, fork it, and the project does not depend on one company. Sophia Stack X's license lets you use it for free and keep everything you make, but you cannot read or fork the program. See [the license](https://sophiastack.sophiaxt.com/license).
## Plugins and extensions
WordPress and Joomla add features through plugins or extensions, and each has a large public directory. A WordPress or Joomla plugin is PHP code that runs inside the same application as the rest of the site, so a plugin can do anything the site can.
Sophia Stack X extensions are a folder with a manifest, templates and JavaScript. The JavaScript runs in a sandbox and can reach only the permissions the manifest declares, such as data or mail. Packages are signed, and the [marketplace](https://sophiastack.sophiaxt.com/marketplace) catalog is signed too, so a package changed on the way is refused. The cost of this design is size: every listing is reviewed by SOPHIA XT, so the marketplace has far fewer items than the WordPress or Joomla directories.
Ghost has integrations and a themes marketplace, and offers a Content API and an Admin API.
## Updates
Sophia Stack X updates with `sophia update --latest`. It checks the release list against an Ed25519 key built into the program, checks the file hash, copies the database, switches versions, and puts the old version back if the new one does not answer within 30 seconds. See [Install](https://sophiastack.sophiaxt.com/install).
For the others, see their own update documentation. WordPress, Joomla and Ghost each have their own routine for core, plugin or theme updates, and the effort depends on your host.
## Static publishing
Sophia Stack X publishes each site as plain HTML files in a numbered release, checks links first, keeps the last ten, and can put any of them back live in one click. Visitors get those files by default, and the files keep working on any web server. The admin is a separate part of the program.
WordPress, Joomla and Ghost render pages from a database when visited, with caching on top, unless you add a tool that exports a static copy. This is a difference in design, not a verdict: a rendered-on-request site can do things a published folder cannot, such as per-visitor pages everywhere. Sophia Stack X handles forms, comments, shop checkout and accounts through its own routes next to the published files.
## AI agent access
Sophia Stack X has an MCP server built into the program, with 55 tools for pages, design, media, publishing, rollback, SEO checks, orders and more. An agent works in drafts, previews a page, sees a dry run of a publish, and can roll back. Every call lands in the audit log. See [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents) and [a CMS AI agents can run](https://sophiastack.sophiaxt.com/ai-cms).
We did not audit what AI integrations the other three offer through their own plugins, add-ons or hosted services. They change quickly, so check their documentation for the current state.
## Moving between them
Sophia Stack X imports WordPress (with WooCommerce and comments), Joomla and Markdown folders, and keeps old addresses working with 301 redirects. The [WordPress migration walkthrough](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress) shows what comes over and what does not. Moving out is simpler than most: published sites are plain HTML with a Markdown copy of every page, and the content is in one SQLite database file.
## When to choose another one
* You need a particular plugin or theme that exists for WordPress or Joomla and has no equivalent here. The ecosystem is where they are strongest.
* You need open-source code you can read, fork or audit yourself.
* You want a large community, many agencies and hosts who know the product, and years of track record.
* You publish newsletters and memberships and want Ghost's focus on them. Sophia Stack X has a newsletter with confirm-by-email and a shop, but it is a general site platform, not a publishing product.
* You want a hosted service run by someone else. Sophia Stack X is self-hosted: you run it. See the support section on the [changelog](https://sophiastack.sophiaxt.com/changelog).
## When Sophia Stack X fits
* You want a single file to run, one database file to back up, and no PHP or Node stack to patch.
* You want the live site to be plain files, with the admin kept apart.
* You want AI agents to do real work on the site with drafts, previews and rollback instead of a free-for-all.
* You build sites for small businesses and want bookings, a newsletter, a shop and an assistant that answers from your own pages included.
Try it without installing anything in the [live demo](https://demo.sophiastack.sophiaxt.com/demo/start), or look at the [benchmarks](https://sophiastack.sophiaxt.com/benchmarks) we measured on one machine.
---
# Documentation | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Documentation
Prefer one file? Download [the whole manual as a PDF](https://sophiastack.sophiaxt.com/pdf/Sophia-Stack-X-Manual.pdf) or [the two-page overview](https://sophiastack.sophiaxt.com/pdf/Sophia-Stack-X-Overview.pdf). AI agents can read every page at once in [llms-full.txt](https://sophiastack.sophiaxt.com/llms-full.txt).
## Using it
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start): from a fresh install to a published site.
* [How a site is put together](https://sophiastack.sophiaxt.com/docs/concepts): pages, blocks, collections, menus, modules, templates and publishing.
* [Publishing, search and AI readers](https://sophiastack.sophiaxt.com/docs/publishing): releases, rollback, SEO, `llms.txt` and Markdown copies.
* [Moving a site in](https://sophiastack.sophiaxt.com/docs/import): WordPress, Joomla, Sophia Stack 2 and Markdown folders.
* [Shop](https://sophiastack.sophiaxt.com/docs/shop): products, options, discount codes, Stripe and orders.
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security and backups](https://sophiastack.sophiaxt.com/docs/security)
## Building on it
* [Building extensions](https://sophiastack.sophiaxt.com/docs/extensions): manifests, templates, `server.js`, data models, admin screens and live page regions.
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents): MCP tools, remote access and the rules agents follow.
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api): read and write content from other apps.
* [SDK and API reference](https://sophiastack.sophiaxt.com/docs/sdk): the OpenAPI spec, TypeScript types for extension code, and the MCP tools.
## Running it
* [Install](https://sophiastack.sophiaxt.com/install)
* [Deploying from your computer](https://sophiastack.sophiaxt.com/docs/deploy)
* [Command reference](https://sophiastack.sophiaxt.com/docs/commands)
* [Full reference for agents and developers](https://sophiastack.sophiaxt.com/download/reference.txt), the same text `sophia docs` prints.
---
# Site accounts and email | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/accounts-email
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Site accounts and email
## Site accounts
Visitors can have accounts on your public site, separate from the people who edit it. Under **Site accounts** choose who can sign up (nobody, invited people, or anyone), which roles new accounts get, and whether they must confirm their email address: not at all, by a link that still lets them in, or before they can sign in.
The pages are `/account/login`, `/account/signup`, `/account` for the profile, and `/account/forgot` for a reset. Reset links last an hour and replace any earlier ones. Confirmation links last three days. Both work once.
Extensions can check a visitor's role, so you can build members-only pages and staff tools. Restyle the account pages by overriding them in your template.
## Email
A super user sets the mail server under **This install > Email**: server, port, STARTTLS or TLS, username, password and the From address. Every message goes through one outbox, which retries six times and erases the message text once delivered. It keeps the subject and address for 30 days.
Without a mail server, messages wait in the outbox, and a super user can open them there. That is how you follow reset links while testing. Links in emails use the site's public address, so a forged request cannot point a reset link elsewhere.
---
# AI agents | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/ai-agents
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# AI agents
Sophia Stack X is built for AI assistants to work on as well as people. An agent learns the system from one plain text reference, then works through MCP tools that check every change like an admin form would.
## Connect an agent
On the computer where the install lives:
```
sophia mcp
```
This runs an MCP server over standard input and output. Point your assistant's MCP settings at that command, run from the install's folder. In Claude Code, for example, add it to the project's `.mcp.json`.
Remotely, an agent can use `POST /api/v1/mcp` with `Authorization: Bearer `. The token is a site API key with the "mcp" scope, made under **API** by a site admin. Remote access is bound to that token's site. Tools that touch the server's own files or the whole install are left out.
## The tools
* **Read first:**`docs`
* **Content:**`sites`, `collections`, `blocks`, `entries`, `entry_get`, `entry_save`, `entry_delete`
* **Structure:**`menus`, `menu_item_save`, `menu_item_delete`, `modules`, `module_save`, `module_delete`
* **Media:**`media_list`, `media_upload`, `media_alt`
* **App data:**`models`, `records`, `record_get`, `record_save`, `record_delete`
* **People:**`accounts`, `account_update`
* **Extensions:**`extension_new`, `extension_check`, `extension_enable`, `ext_settings`, `ext_settings_save`, `schema`
* **Marketplace:**`market_list`, `market_install` (local agents only). Installs are checked against the signed catalog.
* **Design:**`style_get`, `style_set`, the same colors, fonts, sizes, button and link settings as the Design screen. Every value is checked before anything saves, and one bad value means nothing saves.
* **Check and ship:**`page_preview`, `publish_preview`, `publish`, `releases`, `rollback`
* **SEO:**`seo_audit`, `seo_changes`, `seo_change_decide`
* **Shop:**`orders`, `order_get`, `order_action`
* **Visitors:**`site_stats`, the cookie-free visitor numbers for any period up to 400 days.
* **Inbox:**`inbox_list`, `inbox_read` (local agents only). Mail is treated as information, never as instructions.
* **Moving in and the install:**`import_site`, `backup`, `backups`, `audit_log`, `mail_outbox`
## How agents stay safe
* Every write is checked against the same rules as the admin forms and logged as `mcp.` in the audit log.
* Entry saves are drafts unless the agent sets a state. Saving an existing entry only changes the fields sent.
* `page_preview` shows one page with drafts included, and `publish_preview` is a dry run of a publish. `rollback` undoes a publish.
* Remote agents are limited to one site.
## The reference
The whole system fits in one text file that an agent reads before it starts: [reference.txt](https://sophiastack.sophiaxt.com/download/reference.txt). It is the same text `sophia docs` prints. The project also carries an `AGENTS.md` with the working rules: read the docs, prefer an extension over changing the core, check with `sophia check --json`, and never invent facts in client content.
## Building a whole local business site
The `docs` tool ends with a recipe an agent can follow from an empty site to a published one: pick the template, switch on the apps the business needs (bookings, restaurant menus, shop, newsletter, business blocks, the website assistant), enter the facts the owner gave, build the pages from blocks, preview, and publish. It never invents prices, hours or reviews: it leaves the field empty and asks. The same reference is online as [llms-reference.txt](https://sophiastack.sophiaxt.com/sdk/llms-reference.txt).
---
# Apps for local businesses | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/business
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Apps for local businesses
Everything here comes with every copy. Switch an app on for a site under **Extensions**, then set it up from its screen in the admin menu.
## Bookings
Online appointments for salons, barbers, clinics, therapists, contractors and consultants.
* **Services** with a length, a gap after each one, a price and a picture. Each gets its own page with a booking form, and a services page lists them all.
* **Opening hours** per weekday, with breaks (two rows for one day), closed dates, how much notice you need, how far ahead people may book, and how many bookings can share a time when you have several chairs or staff.
* **The booking form** block: pick a service, a day and a free time, then name, email, phone and notes. Free times are worked out live and checked again when the booking is saved, so a time can never be double-booked past its capacity, even when two people press Book at the same moment. It works with scripts off too.
* **Confirm straight away, or review first.** Customers get an email with the details, an "Add to calendar" file and their own cancel link. You get an email for every new booking and cancellation.
* **The Bookings screen** shows today and what's coming, grouped by day, with Confirm, Done, No-show and Cancel, and a CSV export.
Times are the business's own clock time. Set "Hours ahead of UTC" so minimum notice and "today" are right where you are.
## Newsletter
A mailing list you run yourself, done lawfully.
* **The signup** block asks for an email (and a name if you want), shows your consent sentence, and answers in place.
* **Confirm by email** is on by default: people click a link before they're on the list. It keeps typos and other people's addresses out, and many countries require it.
* **Campaigns:** write one, send yourself a test, then send to everyone who confirmed. Each email carries the person's own one-click unsubscribe link and your mailing address, and the app refuses to send without an address. Large lists go out in hourly batches with a Continue button.
* **One-click unsubscribe in mail apps.** Campaign emails carry List-Unsubscribe headers, so Gmail, Outlook and Apple Mail show their own Unsubscribe button next to your name. Gmail and Yahoo expect this from anyone sending to many people.
* **The Subscribers screen** shows counts by status, search, and a CSV export of confirmed addresses.
## Restaurant menus and locations
For restaurants, cafes, bars, bakeries and food trucks, with one location or twenty.
[Play video](https://sophiastack.sophiaxt.com/video/restaurant-inbox.mp4) The restaurant app and the inbox in 39 seconds. The restaurant in it is a made-up sample.
* **Menus you type in once.** Sections like Starters and Drinks, then dishes with a price written the way you say it ($12, 12 / 18, Market price), a line of description, dietary labels (vegetarian, vegan, gluten-free, dairy-free, nut-free, spicy), a photo, and Popular or New tags. Lunch, brunch, drinks and kids menus are separate menus. Already have a printed menu? Add its pictures or the PDF instead.
* **Locations** with address, tap-to-call phone, opening hours (closing after midnight works), a photo, a note like "cash only", and the menus served there, picked from a list.
* **Order, delivery and booking links.** Paste the address from Toast, DoorDash, Uber Eats, Grubhub, OpenTable, Resy, your gift card page or any other service. The button says what it does (Order online, Delivery, Book a table, Gift cards) and each location gets its own.
* **Blocks:** the menu with section links and dietary filter buttons, featured dishes, a location picker that shows today's hours and the right buttons, big order and book buttons, all locations, current promotions, and links per location.
* **Found in search.** Each location page tells search engines it is a restaurant (or cafe, bar, bakery) with its address, hours, cuisine, price range and menu, and each menu page lists dishes with prices.
## Business blocks
Page builder blocks made for local business sites, styled to match every template:
* **Pricing**: up to four plans side by side, one highlighted as the most popular.
* **Team**: photos, names, roles and short bios.
* **Reviews**: customer reviews with stars and an optional summary line you write yourself, linking to where the reviews live. It adds no review markup for search engines, because search engines treat a business's own review markup as spam.
* **Opening hours**: a table with an "Open now" or "Closed, opens at" badge worked out in the visitor's browser. Split days and hours past midnight work.
* **Contact card**: address, a tap-to-call number, email, and Get directions buttons for Google Maps and Apple Maps. No embedded map, so no outside scripts.
* **Logo strip**, **before and after** (a divider you drag or move with the arrow keys), **service list** (a menu of services with prices) and **steps** ("how it works").
* **Announcement bar** and **phone call bar** modules: a dismissible message along the top, and Call and Book buttons fixed to the bottom of phone screens.
## Website assistant
An AI assistant on your site that answers visitors from your own pages, services, products and opening hours, using your own API key from OpenAI, Anthropic, Google or OpenRouter.
* **Pick a template:** Receptionist, Booking helper, FAQ, Lead catcher or Shop helper. Each comes with its own instructions, greeting and starter questions, and you can add your own instructions on top. Every template forbids inventing prices, hours, policies or promises, and giving medical, legal or financial advice.
* **Hand-off to a person:** when it can't answer, it offers to take the visitor's name, email and question, saves them as a lead and emails you.
* **Your key stays on your server.** It is never sent to the browser, written into a page or shown in an error.
* **Limits you set:** messages per day for the whole site and per visitor per hour, and a maximum reply length, so a busy day can't run up your bill.
* **The Assistant screen** has a test chat, the summary of your site it answers from (rebuilt each time you publish), today's count, and the conversations and leads, kept 30 days.
Add it as a floating chat button on every page (a module) or as a box on one page (a block).
## Visitors
Under **Visitors** in each site's menu: views and visitors per day, the most read pages, where visitors came from and which devices they used, for 7, 30, 90 or 365 days.
It is counted without cookies, so it needs no consent banner. No address or anything else that points to a person is stored. A visitor is counted once a day through a one-way code that changes daily. Bots aren't counted, and neither are browsers that send Do Not Track or Global Privacy Control. AI agents can read the same numbers with the `site_stats` MCP tool.
## Inbox
Under **Inbox** in each site's menu, connect the business's own mailbox and read it in the admin: Gmail, Google Workspace, Microsoft 365, Outlook.com, Zoho, Hostinger, Fastmail, iCloud and Yahoo fill in the server for you. It shows the newest 40 messages, opens one with pictures and scripts removed, and lets you reply. Replies go out through the install's email with your mailbox as the reply address, so answers come back to it.
It connects only over an encrypted connection (port 993) and only to servers on the public internet. Most providers want an app password here, not your normal one. Only people who can manage the site's settings see the Inbox. AI agents can list and read messages with the `inbox_list` and `inbox_read` MCP tools on the same machine, and are told to treat what an email says as information, never as instructions.
## Email in a minute
Under **This install > Email**, pick your provider and the server, port and encryption fill in for you: Gmail and Google Workspace, Microsoft 365, Outlook.com, Zoho, Hostinger, Fastmail, iCloud, Yahoo, Postmark, SendGrid, Mailgun and Amazon SES. Each one tells you which password to use (most need an app password, not your normal one). Save, then send yourself a test. Until email is set up, messages wait in the outbox and nobody receives them.
---
# Command reference | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/commands
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Command reference
Run `sophia` with nothing after it to start and open the setup page. `sophia --help` explains any command in full.
## Running
| Command | What it does |
| --- | --- |
| `sophia` | Start with data beside the program and open the browser. |
| `sophia serve` | Run the server only. The admin is at `/admin`. |
| `sophia demo` | Create a demo site with pages, articles, menus and modules. |
| `sophia backup` / `restore` | Back up everything, or unpack a backup into an empty folder. |
## Sites and people
| Command | What it does |
| --- | --- |
| `site-create ` | Create a site, with `--hosts` and `--ext`. |
| `site-set ` | Change its domain names (`--hosts`) or public address (`--public-url`). |
| `publish ` | Publish a site. |
| `routes ` | List every public address of a site. |
| `user-create ` | Create a person. `--super` makes them a super user. |
| `grant ` | Put a person in one of a site's groups. |
| `import ` | Import WordPress, Joomla or Markdown. |
| `import-stack2 ` | Import a Sophia Stack 2 site. |
## Building
| Command | What it does |
| --- | --- |
| `new app\|block\|component\|template ` | Scaffold a working extension. |
| `check ` | Validate an extension. `--json` for agents. |
| `build [folders]` | Build extensions into their `dist` folders. |
| `schema` | Print the JSON Schema for `extension.json`. |
| `docs` | Print the full reference. |
| `mcp` | Run the MCP server for AI agents. |
| `keygen`, `pack`, `trust`, `install` | Make keys, sign packages, trust a publisher, install a package. |
| `market-list`, `market-install ` | List the [marketplace](https://sophiastack.sophiaxt.com/marketplace) and install a free extension from it, checked against the signed catalog. |
## Servers
| Command | What it does |
| --- | --- |
| `server-install` | On a Linux server, as root: install as a service. |
| `update --latest` | Update to the newest signed release. |
| `update ` | Update from a program or bundle file. |
| `deploy ` | Install or update a server over ssh. |
| `bundle` | Pack the Linux program with the built extensions. |
| `release --key ` | Write a signed download folder. |
| `ping ` | Check that a server answers. |
## Options for every command
| Option | What it does |
| --- | --- |
| `--root ` | The folder holding `data` and `extensions`. |
| `--data ` | The data folder (database, sites, installed packages). |
| `--bind ` | The address to serve on, such as `127.0.0.1:8806`. |
Settings can also come from the environment: `SOPHIA_DATA`, `SOPHIA_BIND`, `SOPHIA_SECURE_COOKIES=1` behind HTTPS, `SOPHIA_AI_URL` and `SOPHIA_AI_MODEL` for a local model.
---
# How a site is put together | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/concepts
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# How a site is put together
## Sites
One install holds any number of sites. Each has its own content, menus, template, people and settings, and answers on its own domain names. People get access per site through groups such as Owner, Editor, Author and Viewer.
## Collections and entries
Content lives in collections: pages, articles, products, events, forms and whatever your extensions add. Each collection lists its fields, so the admin shows the right form and every saved value is checked against it. Rich text is cleaned, links are checked and unknown keys are dropped.
Entries can be drafts, scheduled for later, published or unpublished. Sites can be in several languages, with translations of an entry linked together.
## Pages and blocks
Pages are built from blocks: hero, text, image, gallery, columns, cards, stats, call to action, quote, FAQ, video, latest entries, spacer, plus blocks from extensions such as forms, products and comments. The page builder previews them through the site's real template as you edit.
Each block has a Design tab in the builder: a solid, gradient or picture background (with an overlay so words stay readable), space above and below, content width, text color, hiding on phones or desktops, and an anchor for links like `#pricing`. Text color is picked for contrast on the background unless you choose one. In the page data this is an optional `style` object on the block, so agents can set it too: see Section style in the reference (`sophia docs`).
The Design tab also shapes and animates a section: rounded corners, shadow or glow, a border, a frosted glass card, minimum height (half or full screen), wave, angle or curve dividers that blend into the neighbouring section, a fixed parallax background on wide screens, headings in the site's accent gradient, and an entrance animation (fade, fade up, zoom, slide) with an optional delay. Animations only hide a section while the page's small script is running; without it, in static exports and for visitors who ask for reduced motion, everything is simply visible.
## Section library
The builder offers a library of ready-made sections: heroes (including a deep space one, a split with a product shot, a centered gradient and a full-screen picture), features, pricing, testimonials, calls to action, FAQ, stats, logos, contact, gallery, team and a closing section. Each is a normal block with its design already set, so you change it like any other. The words in them are placeholders (testimonials read "Your customer's words here", numbers and prices are marked as examples): replace them with your own before you publish. Agents use the `section_presets` and `page_add_section` tools.
## Menus route
A menu item gives a page its address. Items can point at one page, a list of entries (a blog, a product list), a link elsewhere, or a heading that groups items. List items give each entry in the collection its own page under the list's address. If you rename a menu item, its address changes with it.
## Modules and positions
A template names positions such as header actions, sidebar, content top and bottom, and footer columns. Modules fill them: a menu, a block of HTML, contact details, a latest-entries list, a language switcher, a cart link or comments. Each module can show on every page or only on chosen ones.
## Templates
A template is an extension that holds the page frame and the look. It lists its positions and the settings it offers, such as a logo, a tagline and colors. The default template, Aurora, has nine positions. Any template can override another extension's views by placing files at `overrides//`. A template can also list the parts of its look that the **Design** screen may change, such as its colors, fonts, sizes and corner rounding. AI agents change the same values through MCP.
Every site also gets two sets of Design settings that work with any template: **Buttons** (corner rounding, height, width, text size and weight, capitals, letter spacing, the main button's color and text color, border, shadow, hover motion and hover brightness) and **Links and focus** (underlines in text, the underline gap and the keyboard focus ring). Each one leaves the template's own look alone until you change it. Three button presets fill in a set at once: pill buttons, square bold capitals, and soft and lifting.
## Extensions
Everything beyond the core comes from extensions: the blog, shop, forms, events, comments, restaurant and help desk apps. Switch them on per site under **Extensions**. See [Building extensions](https://sophiastack.sophiaxt.com/docs/extensions) to make your own. Extensions can also be packed and signed into `.sxp` packages, and an install accepts a package only when a key it trusts signed it.
## Publishing
By default visitors get published files. Publishing renders every page into a new release folder, checks it and switches over. That makes pages fast and cacheable, and leaves nothing to attack on the public side but plain files. Account pages, forms, the cart, comments and extension routes stay live, because they need the program. A site can also be set to render every request live instead.
Sites can republish themselves daily or hourly, which keeps date-based lists such as upcoming events current.
---
# Content API | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/content-api
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Content API
Other apps, such as a mobile app or a separate front end, can read and write a site's content over HTTP. Make a key under **API** in the site's admin and send it as `Authorization: Bearer `.
| Request | What it returns |
| --- | --- |
| `GET /api/v1/site` | The site's name and languages, and each collection with its fields. |
| `GET /api/v1/content/` | Published entries of a collection. |
| `GET /api/v1/content//` | One entry. |
| `GET /api/v1/menus/` | A menu with its items. |
| `POST /api/v1/content/` | Create an entry, when the key has the write scope. |
Keys belong to one site and carry scopes, so a read-only key cannot change anything. The "mcp" scope lets an AI agent use the [MCP tools](https://sophiastack.sophiaxt.com/docs/ai-agents) remotely.
---
# Deploying from your computer | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/deploy
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Deploying from your computer
If you build sites on your own computer, one command puts them on a Linux server over ssh:
```
sophia deploy root@server --domain example.com --tls-email you@example.com --with-data --site my-site
```
It needs an ssh key for the server, systemd there, and root or passwordless sudo. The first run installs, and every run after that updates, the same way the [server installer](https://sophiastack.sophiaxt.com/install) does: its own account, a sandboxed service on `127.0.0.1`, nginx or Caddy in front, and HTTPS.
## What each option does
| Option | What it does |
| --- | --- |
| `--domain` | Names to serve, set up in nginx or Caddy. |
| `--site ` | The site that answers on those names. Its public address is set to match. |
| `--with-data` | Copy this install's content, pictures and accounts. Passwords travel too, so change any starter password once it is live. |
| `--replace-data` | Overwrite content already on the server. The old folder is kept beside it. |
| `--status` | Show the version in use, whether the service runs and whether it answers. |
| `--rollback` | Go back to the earlier program. Content is left as it is. |
| `--port`, `--key` | The ssh port and key file. |
| `--binary` | The Linux program to send, if not `dist-linux/sophia`. |
## How an update protects the site
The service stops, the database is copied, the new version takes over, and the deploy waits for `/healthz` to answer. If it does not answer within 30 seconds, the previous version and the database copy come back by themselves. Three versions and three database copies are kept.
## A public demo
Set `SOPHIA_DEMO` to the email of an account and the install becomes a demo anyone can click through:
* `/admin/login` signs visitors in as that account with one click. No password is asked for or checked.
* Nothing can be changed. Saving, publishing, uploads and every other change are refused; the builder's live preview still works.
* Pages that show sign-ins, addresses, tokens or install settings are left out.
* Every admin page carries a bar saying it is a demo.
* Mail is never sent. Everything stays in the outbox.
### Private workspaces
A demo also offers each visitor a workspace of their own at `/demo/start`: a site built from the bakery starter, published once, that they can change, publish and roll back for an hour. The published site shows at `/w//`.
* The workspace account is not a super user and belongs only to its own site. It cannot open other sites, the install's settings, or the parts of its own site that reach outside: site addresses, imports, plugins, API tokens and people.
* `/w/` pages are served with a sandbox content policy, so nothing on them can act as the visitor on the demo's address.
* Other visitors, including the shared read-only account, cannot see or open it.
* At most 25 run at once and one address can start 3 an hour. Uploads are limited to 6 MB. Expired workspaces are deleted with their account and files.
* The bakery uses the Hearth template when it is installed (`sophia market-install hearth`) and photos from `/starters/bakery` when they are there.
Run it as its own install with its own data, never on a live site. Our demo at [demo.sophiastack.sophiaxt.com](https://demo.sophiastack.sophiaxt.com/admin) runs this way.
## Building the programs
Developers working from the source run `scripts/build-linux.ps1` on Windows. It makes a fully static Linux program that runs on any 64-bit Linux without extra libraries; `-Target aarch64-unknown-linux-musl` builds for ARM servers, and `-Target aarch64-apple-darwin` or `x86_64-apple-darwin` for Macs. `sophia bundle` packs that program with your built extensions, and `sophia release` writes a signed download folder like the one this site serves.
---
# Building extensions | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/extensions
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Building extensions
An extension is a folder. It can add content types, page blocks, modules, a whole template, data models with admin screens, web routes and background reactions to events. Server code is JavaScript in a sandbox. There is no Node, no npm and no build tool to install.
## Start one
From a folder that has an `extensions` directory:
```
sophia new app my-app # also: block, component, template
sophia check extensions/my-app # add --json for a machine-readable report
```
`check` validates the manifest, parses every template and compiles `server.js`. Then switch the extension on for a site under **Extensions**, or with the `extension_enable` tool.
## The folder
```
extension.json the manifest
templates/*.html Jinja templates; names are ":"
server.js optional server code
css/, js/, img/ sources bundled by "sophia build" (minified and fingerprinted)
```
After editing, run `sophia check` and `sophia build`, then restart or press **Reload extensions**.
## The manifest
Every key is optional except `name`:
```
{
"name": "tickets",
"title": "Tickets",
"version": "0.1.0",
"kind": "app",
"description": "A small support desk.",
"server": "server.js",
"permissions": ["data", "mail"],
"collections": [{ "key": "faq", "label": "FAQs", "fields": [{ "name": "answer", "label": "Answer", "type": "richtext" }] }],
"models": [{ "key": "ticket", "label": "Tickets", "title_field": "subject",
"fields": [{ "name": "subject", "label": "Subject", "type": "text", "required": true }] }],
"blocks": [{ "type": "promo", "label": "Promo", "template": "blocks/promo.html", "fields": [] }],
"modules": [{ "type": "hours", "label": "Hours", "template": "modules/hours.html", "fields": [] }],
"admin": [{ "key": "queue", "label": "Support queue", "perm": "content.edit" }],
"settings": [{ "name": "notify", "label": "Email me at", "type": "email" }]
}
```
Field types: `text`, `textarea`, `richtext`, `number`, `toggle`, `select`, `image`, `file`, `url`, `date`, `color`, `code`, `email`, `secret`, `list` (with its own fields) and `item` (a link to another entry). Saved values are always cleaned against the fields.
`sophia schema` prints the full JSON Schema of the manifest.
## Templates
Templates use Jinja syntax. They see the site, the page, menus, the current entry or list, block and module settings, and the template's own settings as `theme`. Helpers include `position()`, `asset()`, `link()`, `t()` for translated strings, `render_blocks()`, and the filters `excerpt`, `date`, `time12`, `tel` and `money`.
## Server code
```
sx.route("GET", "/open", (req) => ({ json: sx.data.list("ticket", { where: { status: "open" } }) }));
sx.route("POST", "/new", (req) => {
if (!sx.rateLimit("ip:" + req.ip, 5, 3600)) return { status: 429, text: "Slow down." };
sx.data.create("ticket", { subject: String(req.form.subject || "").slice(0, 200), status: "open" });
return { redirect: "/x/tickets/thanks" };
});
sx.admin("queue", (req) => ({ html: sx.render("queue.html", { rows: sx.data.list("ticket", {}).items }) }));
sx.on("record.saved", (event) => sx.log("saved", event));
```
Routes answer at `/x//`. A route returns `{ json }`, `{ html }`, `{ text }`, `{ page: { title, html } }` (wrapped in the site's layout) or `{ redirect }`, with optional `status` and `headers`.
The request carries method, path, params, query, body, json, form, headers, ip, the signed-in site account and the site.
What code may call depends on its declared permissions:
| Call | Permission |
| --- | --- |
| `sx.data.list / get / create / update / remove` | `data` |
| `sx.content.list / get` | `content.read` |
| `sx.content.draft` (an editor publishes it) | `content.write` |
| `sx.accounts.get / list / setRoles` | `accounts` |
| `sx.http.fetch(url, ...)` | `http:` for each host |
| `sx.mail.send({ to, subject, text })` | `mail` |
Always available: `sx.settings()`, `sx.site()`, `sx.render()`, `sx.escape()`, `sx.log()`, `sx.rateLimit()` and `sx.requireRole(req, "staff")`. Each call runs fresh with a memory and time limit (64 MB, 3 seconds by default).
## Live page regions
Parts of a page can update from the server without a reload, with no framework and no build step. Include the core script and mark the region:
```
Open
```
`data-sx-live` loads the region from a route that returns `{ html }`, and `data-sx-every` refreshes it every so many seconds while the tab is visible. A form or link with `data-sx-target` sends through fetch and swaps the answer into the target. `data-sx-swap="outer"` replaces the element itself. The route sees `req.live` as true, so one route can answer a whole page or just the part.
## Rules worth keeping
* Escape anything a visitor typed with `sx.escape` before putting it in HTML.
* Declare only the permissions you use. Secrets go in settings fields of type `secret`.
* Content written from code is saved as a draft. People publish.
## Packing and signing
```
sophia keygen my.key
sophia pack extensions/my-app --key my.key
sophia trust # on the install that will accept it
sophia install packages/my-app-0.1.0.sxp
```
A package installs only when a key that install trusts signed it.
The help desk extension that ships with Sophia Stack X is a complete example of an app with models, admin screens, routes and email.
---
# Forms, events and comments | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/forms-events-comments
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Forms, events and comments
## Forms
Build contact, quote and sign-up forms under **Content > Forms**: pick the questions (text, email, phone, long text, number, date, choice, checkbox), the button text, the thank-you message and who gets each answer. Place a form on any page with the **Form** block.
Answers are checked against the form's own questions, kept under **Form answers** and emailed with the sender as the reply-to address. Spam checks are a hidden field bots fill, a minimum time on the page, and a per-visitor hourly limit.
## Events
Events have a start date and time, an end, a place and address, an online link, a summary, a picture, a description, a price, a tickets link and a status: scheduled, cancelled, postponed or sold out. The events list shows upcoming ones, and the **Upcoming events** block shows the next few anywhere. Each event page has an add-to-calendar file and schema.org event markup for search engines.
Turn on **Settings > Publish automatically** so past events drop off the list without anyone republishing.
## Comments
Switch on the Comments extension, then add the **Comments** block to a page or put the **Comments** module in the content-bottom position. For articles only, set the module's "only on addresses starting with" to `/blog/`.
Pages stay as published files, and new comments appear without a republish. By default each comment waits under **Moderate comments** until you approve it. The settings can let signed-in visitors through at once, or open comments to everyone.
Comments hold plain text only, so nobody can slip markup or scripts into your pages. Email addresses never reach the public page. Spam checks are a hidden field, a minimum time on the page, an hourly limit per visitor, repeat detection and your own blocked words. A comment with more than two links always waits for you.
---
# Moving a site in | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/import
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Moving a site in
Open **Import** under a site, run `sophia import `, or have an agent use the `import_site` tool. The importer shows what is in the file before writing anything, then runs in the background.
## From WordPress
In WordPress, use **Tools > Export > All content** to get an `.xml` file. The importer brings over:
* pages and posts with their dates, authors, categories and tags, drafts and private posts as drafts;
* the pictures those pages use, from a copy of `wp-content/uploads` or downloaded from the old site;
* menus, and the home page;
* WooCommerce products with sale prices, stock, galleries and variations, which become product options;
* approved comments with their replies, skipping spam and pingbacks.
It cleans the HTML, keeps the paragraphs of classic-editor posts, and removes plugin shortcodes, which it lists in the report. Custom post types from plugins do not come over.
## From Joomla
Export the database as an `.sql` dump, for example from phpMyAdmin. Articles, categories and menus come over. An article a menu links to directly becomes a page, and the rest become articles. Give the old address with `--old-url`, because Joomla dumps do not include it.
## Addresses and links
Every old address answers with a 301 redirect to its new page, and links inside the text are repointed. Running the import again updates what it brought in instead of making copies.
Importing into an existing site keeps its home page and its blog or shop list. Add `--set-home` to replace the home page with the imported one.
## From a folder of Markdown files
```
sophia import ./my-site --as my-site --name "My site"
```
Each `.md` file becomes a page. `index.md` at the top is the home page. A subfolder with its own `index.md` becomes a section, and its other files go in that section's submenu. A short header sets details:
```
---
title: Install
menu: Install
description: One sentence for search results.
order: 2
nav: false
---
```
Without a title, the first `#` heading is used. File names can start with a number to set the order, as in `02-install.md`, and the number is not part of the address. Tables, task lists and code blocks work. This site is kept that way.
## From Sophia Stack 2
`sophia import-stack2 ` copies a site from the earlier Node version. It reads a backup copy of the database and never changes the source.
## Command options
| Option | What it does |
| --- | --- |
| `--into ` | Import into a site that already exists. |
| `--as --name ` | Make a new site. |
| `--template ` | Template for a new site (default `aurora`). |
| `--hosts a.com,www.a.com` | Domain names for a new site. |
| `--uploads ` | A copy of the old site's files, for pictures. |
| `--download` | Fetch pictures from the old site instead. |
| `--dry-run` | Only show what is in the file. |
---
# Migrate from WordPress | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Migrate from WordPress
# Migrate from WordPress
This walkthrough moves a WordPress site into Sophia Stack X and keeps its old addresses working. The importer is described in [Moving a site in](https://sophiastack.sophiaxt.com/docs/import). Here the steps come in order, with the checks to run before you switch your domain. Your WordPress site is never touched: the importer only reads the export file.
## What comes over, and what does not
Comes over:
* Pages and posts, with dates, authors, categories and tags. Drafts and private posts arrive as drafts.
* The pictures those pages use, from a copy of `wp-content/uploads` or downloaded from the old site.
* Menus, and the home page.
* WooCommerce products with sale prices, stock, galleries and variations (variations become product options).
* Approved comments with their replies. Spam and pingbacks are skipped.
Does not come over:
* Plugin shortcodes. The importer removes them and lists them in its report, so you can rebuild what they did with blocks or an extension.
* Custom post types made by plugins.
* Your WordPress theme. You pick a Sophia Stack X [template](https://sophiastack.sophiaxt.com/templates) and set colors and fonts on the Design screen.
* Plugin settings and plugin data such as form entries.
Check the list against your site first. If a plugin does something important, such as a booking form, look for the matching built-in app (bookings, forms, newsletter, shop) before you start.
## Steps
**1\. Get Sophia Stack X running.** [Install it](https://sophiastack.sophiaxt.com/install) on your computer. Do the first run on your own computer, not on the live server, so a mistake costs nothing.
**2\. Export from WordPress.** In WordPress, open Tools, then Export, choose All content, and download the `.xml` file. For WooCommerce, the same export includes products.
**3\. Copy the pictures (best), or let the importer fetch them.** Copy the `wp-content/uploads` folder from your host to your computer and pass it with `--uploads`. If you cannot, use `--download` and the importer fetches the pictures from the old site.
**4\. Do a dry run.** It lists what is in the file and writes nothing:
```
sophia import export.xml --as my-site --name "My site" --dry-run
```
**5\. Import for real** into a new site:
```
sophia import export.xml --as my-site --name "My site" --uploads ./uploads --hosts example.com,www.example.com
```
You can also use **Import** in the admin or have an agent call the `import_site` tool. Importing again updates what it brought in instead of making copies, so you can fix and re-run. To import into a site that already exists, use `--into ` in place of `--as`. That keeps the site's own home page and blog list, unless you add `--set-home`.
**6\. Read the report.** It lists removed shortcodes and anything skipped. Open the site in the admin and look at the home page, a post with pictures, a menu, and a product if you have a shop.
**7\. Pick a template and publish.** Choose a template under Settings, set the look on the Design screen, then publish. Publishing checks links, picture descriptions and leftover placeholder text before it goes live.
## Check the redirects before you switch
Every old WordPress address answers with a 301 redirect to its new page, and links inside the text are repointed. 301 is the permanent redirect search engines follow to carry rankings across. Check it yourself, do not trust it:
1. In WordPress, make a list of your most important addresses: the home page, your ten top posts, your product pages and any page people link to.
2. Run the new site on a test address and request each old path, for example `curl -I -H "Host: example.com" http://127.0.0.1:8806/2023/05/old-post/`, with your site's domain as the host. A good answer is a `301` with a `location` header pointing at the new page, and the new page then answers `200`.
3. Fix any miss. A page that was not imported, or an address a plugin made, will not redirect. Recreate that page at the same address (a menu item gives a page its address) and publish again. See [Publishing](https://sophiastack.sophiaxt.com/docs/publishing#redirects).
## Switch your domain
1. [Deploy to a server](https://sophiastack.sophiaxt.com/docs/deploy) (or use the one-command installer on the [Install](https://sophiastack.sophiaxt.com/install) page) with your domain, and send the new site there.
2. Turn the site's public address on under Settings so the sitemap and canonical links use your real domain. Look at the SEO audit.
3. Point your domain's DNS at the new server. Keep the old WordPress hosting running for a few days, so you can go back if needed.
4. Take a backup (`sophia backup`) once the site is live, and again after any big change. See [Security and backups](https://sophiastack.sophiaxt.com/docs/security).
5. If you use Google Search Console, submit the new sitemap and watch for crawl errors on old addresses.
## If something goes wrong
Nothing here touches your WordPress site until you change DNS. Before that, a bad import costs you a delete. After the switch, every publish is a numbered release, so the last ten versions go back live in one click, and the old hosting is still there until you cancel it.
## Next
* [Moving a site in](https://sophiastack.sophiaxt.com/docs/import): the importer for Joomla and Markdown too
* [Compare](https://sophiastack.sophiaxt.com/compare): where WordPress is the better choice
* [Try the live demo](https://demo.sophiastack.sophiaxt.com/demo/start) before you move anything
---
# Publishing, search and AI readers | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/publishing
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Publishing, search and AI readers
## Releases and rollback
**Publish** renders every route into a new release folder, checks links, picture descriptions and leftover placeholder text, then switches visitors to it. The last ten releases are kept. Any of them can be made live again with one click, and so can a publish an AI agent made.
Before publishing, a dry run shows which pages would be added, changed or removed, and any page that would fail.
Under **Settings > Publish automatically** a site can republish daily or hourly. A run that would change nothing makes no release, so your rollback history stays useful. Anything saved as published goes online at the next run without anyone pressing Publish.
## Redirects
Old addresses can point at new ones with real 301 redirects, which keep search rankings. Imports set these up for you. Each release also carries `_redirects.nginx` for sites where nginx serves the files directly.
## SEO
The SEO extension adds:
* an audit of titles, descriptions, headings, links and pictures, with suggested fixes you approve before they apply;
* page titles and descriptions, canonical links and language alternates;
* structured data (JSON-LD) for the organisation, local business details, FAQs and events;
* `robots.txt` presets, including choices about AI crawlers;
* a sitemap, which needs the site's public address under **Settings**;
* social share tags (Open Graph and X cards) on every page, with the share picture set under **SEO > Files > Sharing**. A page with its own picture field, such as an article's cover, uses that picture instead.
## RSS feed
When a site has dated entries, such as blog articles, every publish writes `/feed.xml`: an RSS 2.0 feed of the 30 newest, with the full text and full addresses for links and pictures. Every page links it from its head, so browsers, feed readers and AI agents find it. There is nothing to switch on.
## What AI readers get
AI assistants and answer engines read plain text better than designed pages, so every published site also carries:
* **`index.md` beside every page.** A clean Markdown copy of the page's main content, linked from the page with `rel="alternate" type="text/markdown"`. Navigation, forms and scripts are left out.
* **`llms-full.txt`.** Every page of the site in one Markdown file. `llms.txt` links each page's Markdown copy and this file.
* **Tables stay tables.** Copies keep tables as Markdown tables and use full addresses for links and pictures, so a copy pasted somewhere else still points the right way.
* **`llms.txt`.** A map of the site in the [llmstxt.org](https://llmstxt.org) format, written by the SEO extension.
* **Markdown on request.** A request that sends `Accept: text/markdown` gets the Markdown copy of the page instead of the HTML.
Parts of a page that the browser fills in, such as comments and live regions, are not in the copies.
---
# Quick start | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/quick-start
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Quick start
This takes about ten minutes. It assumes you have [installed](https://sophiastack.sophiaxt.com/install) Sophia Stack X and finished the setup page.
## 1\. Look around the dashboard
After setup you land on your site's dashboard. It shows whether the site is online, how many saved changes are waiting to be published, and the next steps. The menu on the left holds everything for this site:
* **Content:** your pages, articles and any other kinds of entries your extensions add.
* **Structure:** menus, modules and extensions.
* **Site:** publishing, search, people, site accounts, the audit log, API keys, importing and settings.
**Preview site** opens the site as visitors will see it, with your unpublished drafts included.
## 2\. Edit the home page
Open **Pages**, then **Home**. The page builder shows the page through your site's own template and updates as you type. Each part of the page is a block. Click one to change it, drag to reorder it, or add new blocks from the list. Save when you are done.
Saved changes stay private until you publish.
## 3\. Add a page and put it in the menu
Create a page under **Pages**, give it a title and some blocks, and save it. Then open **Menus**, add an item to the main menu that points at your new page, and save. Menus decide which pages have addresses: a page is reachable at the address its menu item gives it.
## 4\. Publish
Open **Publish** and press **Publish the site**. Sophia Stack X builds every page into a new version of the site, checks for broken links, pictures without descriptions and placeholder text, then switches visitors over. If a page would not render, the publish stops and the live site stays as it was.
Every published version is kept, the last ten of them. If something looks wrong, make an earlier one live again with one click.
## 5\. Make it yours
* **Settings:** the site's name, web address, languages and template.
* **Design:** colors, fonts, sizes and shape, beside a live preview at phone, tablet and desktop widths, with a contrast check on text colors.
* **Extensions:** switch on the blog, shop, forms, events or comments.
* **Modules:** put menus, contact details and lists into the template's positions, such as the sidebar or footer.
* **SEO:** search settings, structured data and the `llms.txt` file for AI agents.
## Next
* [How a site is put together](https://sophiastack.sophiaxt.com/docs/concepts)
* [Building extensions](https://sophiastack.sophiaxt.com/docs/extensions)
---
# SDK and API reference | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/sdk
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# SDK and API reference
Three ways to build on Sophia Stack X, each with a machine-readable reference so your editor, your code generator or your AI agent gets exact names instead of guesses.
## The content API, as OpenAPI
Every install serves an OpenAPI 3.1 description of its content API at `/api/v1/openapi.json`. It needs no token, and it holds no site data. Feed it to any OpenAPI generator to get a typed client in TypeScript, Python, Go, Swift or anything else, or hand it to an AI agent.
* Download: [openapi.json](https://sophiastack.sophiaxt.com/sdk/openapi.json)
* What it covers: the site and its collections with their fields, listing and reading live entries, creating drafts, menus as trees, and MCP over HTTP.
* Auth: `Authorization: Bearer sxt_...`, a site token with the read, write or mcp scope. See [Content API](https://sophiastack.sophiaxt.com/docs/content-api).
```
npx @openapitools/openapi-generator-cli generate -i https://your-site.com/api/v1/openapi.json -g typescript-fetch -o ./sophia-client
```
## Types for extension code
`sophia new app ` puts `sophia.d.ts` into the new extension, and `server.js` points at it. Editors that understand TypeScript, such as VS Code, then autocomplete and check every `sx` call: routes and the request object, the extension's data models, content, accounts, mail, outbound HTTP, rate limits and escaping.
* Download: [sophia.d.ts](https://sophiastack.sophiaxt.com/sdk/sophia.d.ts)
* To check a file from a terminal: `npx tsc --noEmit --checkJs --allowJs server.js sophia.d.ts`
```
///
sx.route("POST", "/tickets", (req) => {
if (!sx.rateLimit(req.ip, 5, 600)) return { status: 429, text: "Slow down" };
const t = sx.data.create("ticket", { subject: req.form.subject });
return { redirect: "/x/tickets/tickets/" + t.id };
});
```
## MCP tools
The 55 MCP tools describe themselves: an MCP client lists them with `tools/list`, each with a JSON Schema for its arguments. Run them locally with `sophia mcp`, or over HTTP at `/api/v1/mcp` with a token that has the mcp scope. See [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents).
## Everything in one file for AI agents
[/llms-full.txt](https://sophiastack.sophiaxt.com/llms-full.txt) is this whole site as Markdown, and `sophia docs` prints the full reference for building on the stack. Point an agent at either before it writes an extension.
---
# Security and backups | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/security
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Security and backups
## Signing in
Passwords need at least 12 characters and are stored with Argon2. Repeated failed sign-ins from one address are slowed down. Anyone can turn on two-step sign-in with an authenticator app, and gets recovery codes for a lost phone. A super user can require it for everyone.
Under your account you can see every signed-in session, with its browser and address, and end any of them.
## The audit log
Every change by a person, a command or an AI agent is written to the audit log with who made it and when. Agent changes are marked with the tool they used.
## Backups
**Back up now** in the admin, or `sophia backup`, writes one zip with a consistent copy of the database, every site's pictures, installed extensions, trusted keys and settings. Published releases are left out, because publishing rebuilds them. Fourteen backups are kept by default.
To restore, unpack a backup into an empty folder with `sophia restore --into `, then start the program with `--data `.
## The install checklist
**This install > Security** lists what still needs doing before a site is public: HTTPS cookies, developer mode off, public addresses set, a mail server, two-step sign-in for every admin, and a recent backup.
## How it is built to be safe
* Visitors get published files by default, so most of the site is plain files with nothing to attack.
* On a server, the program runs as its own account in a systemd sandbox, can write only its data folder, and listens only on `127.0.0.1` behind your web server.
* Extension code runs in a sandbox and gets only the permissions its manifest declares and the site allows.
* Every form is checked against its schema, and every admin form against a per-session token.
* Packages install only when a trusted key signed them, and program updates only when the SOPHIA XT release key signed them.
---
# Shop | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/docs/shop
Docs
* [Overview](https://sophiastack.sophiaxt.com/docs)
* [Quick start](https://sophiastack.sophiaxt.com/docs/quick-start)
* [Concepts](https://sophiastack.sophiaxt.com/docs/concepts)
* [Publishing and SEO](https://sophiastack.sophiaxt.com/docs/publishing)
* [Importing](https://sophiastack.sophiaxt.com/docs/import)
* [Shop](https://sophiastack.sophiaxt.com/docs/shop)
* [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress)
* [Forms, events and comments](https://sophiastack.sophiaxt.com/docs/forms-events-comments)
* [Site accounts and email](https://sophiastack.sophiaxt.com/docs/accounts-email)
* [Security](https://sophiastack.sophiaxt.com/docs/security)
* [Extensions](https://sophiastack.sophiaxt.com/docs/extensions)
* [AI agents](https://sophiastack.sophiaxt.com/docs/ai-agents)
* [Content API](https://sophiastack.sophiaxt.com/docs/content-api)
* [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)
* [Commands](https://sophiastack.sophiaxt.com/docs/commands)
* [SDK](https://sophiastack.sophiaxt.com/docs/sdk)
* [Business apps](https://sophiastack.sophiaxt.com/docs/business)
# Shop
Switch on the Shop extension under **Extensions**, then add products under **Content > Products**. Link the product list from a menu item that lists the product collection.
## Products
A product has a price, an optional "compare at" price to show a sale, a picture and gallery, a summary and description, a SKU, stock (leave it empty for unlimited), a category and whether it ships. Options such as sizes or colors each carry their own price and stock.
Place products on any page with the **Product grid** and **Buy box** blocks, and put the **Cart link** module in the header.
## Prices you can trust
The cart lives in the visitor's browser, but the server prices every order again from your products at checkout: items, discount, tax at one rate, and shipping that can be flat, free over an amount, or pickup. Nothing the browser sends can change a price.
## Discount codes
Add codes in the shop settings, each with a percent or amount, an optional minimum, an end date and a use limit. The discount comes off the items before tax, and free shipping is judged after it.
## Payment
* **Stripe Checkout:** put your Stripe secret key and webhook secret in the shop settings, and point a Stripe webhook for `checkout.session.completed` at `https:///x/shop/stripe`. Webhooks are checked against their signature.
* **Pay later:** for pickup, invoices or cash.
## Orders
Orders are numbered from 1001 per site. Each one gets a private link for the customer, a receipt email and an alert to the store. Stock counts down when an order is paid (pay later: when it is placed), and goes back if you cancel. **Orders** in the admin lists, filters and exports them as CSV. Only people with the orders permission see customer details.
---
# Install Sophia Stack X | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/install
# Install Sophia Stack X
Three steps, about two minutes. No database to create, no PHP, no config file to edit.
1. **Download** the program for your system from the table below.
2. **Open it.** It makes its data folder, starts, and opens the setup page in your browser.
3. **Fill in the setup page:** your name, email, a password, your site's name and a starting point. You land in the admin with a working site.
## The whole setup is one page.
Pick a template and a starting point: blank, business, blog, restaurant, or a finished bakery with a shop. Search basics are on from the first publish: a sitemap, canonical links, social share tags, llms.txt and a Markdown copy of every page.
* One account, the owner, made on the spot
* One database file, made for you
* Locked to this computer, or to a one-time link on a server

Want to try it first? [Build a bakery in a private workspace](https://demo.sophiastack.sophiaxt.com/demo/start): edit, publish and roll back for an hour, nothing to install. Or [look around the read-only demo](https://demo.sophiastack.sophiaxt.com/admin). Want to check a download before you run it? See [Check your download first](#check-your-download-first).
## On your computer
Download the program for your system:
| System | File |
| --- | --- |
| Windows 10 or 11, 64-bit | [sophia-windows-x86\_64.exe](https://sophiastack.sophiaxt.com/download/sophia-windows-x86_64.exe) |
| Linux, 64-bit Intel or AMD | [sophia-linux-x86\_64](https://sophiastack.sophiaxt.com/download/sophia-linux-x86_64) |
| Linux, 64-bit ARM | [sophia-linux-aarch64](https://sophiastack.sophiaxt.com/download/sophia-linux-aarch64) |
| macOS, Apple silicon (M1 and later) | [sophia-macos-aarch64](https://sophiastack.sophiaxt.com/download/sophia-macos-aarch64) |
Sophia Stack X is free to use under the [SOPHIA XT license](https://sophiastack.sophiaxt.com/license).
## Check your download first
Every download is on a list, `latest.json`, that names each file and its SHA-256. SOPHIA XT signs that list with an Ed25519 release key, and the public key is published as [release-key.pem](https://sophiastack.sophiaxt.com/download/release-key.pem). Check the signature once, then check your file against the list. Two minutes, and you know the file is the one we published. [Verify a download](https://sophiastack.sophiaxt.com/verify) has the full steps and the key itself.
**Windows exe: not code-signed yet.** We have not bought a code-signing certificate, so Windows may show a warning for `sophia-windows-x86_64.exe` the first time. That warning is expected for now. It does not tell you the file is bad, and it does not tell you the file is good. Use the hash check below to see whether it is the file we published. Do not turn off Windows security features to run it.
On Windows, in PowerShell, from the folder with your downloads (`certutil` ships with Windows, and openssl 3 is needed only for the signature):
```
$B = "https://sophiastack.sophiaxt.com/download"
curl.exe -fsSLO "$B/latest.json" -O "$B/latest.json.sig.bin" -O "$B/release-key.pem"
# 1. The list is signed by SOPHIA XT (needs openssl 3). Prints "Signature Verified Successfully".
openssl pkeyutl -verify -pubin -inkey release-key.pem -rawin -in latest.json -sigfile latest.json.sig.bin
# 2. Your file's hash. It must be the same as the entry for it in latest.json.
certutil -hashfile sophia-windows-x86_64.exe SHA256
Select-String -Path latest.json -Pattern "sophia-windows-x86_64.exe" -Context 0,2
```
On Linux or a Mac, the same with `sha256sum` or `shasum -a 256`:
```
B=https://sophiastack.sophiaxt.com/download
curl -fsSLO $B/latest.json -O $B/latest.json.sig.bin -O $B/release-key.pem
openssl pkeyutl -verify -pubin -inkey release-key.pem -rawin -in latest.json -sigfile latest.json.sig.bin
sha256sum sophia-linux-x86_64
grep -A1 '"sophia-linux-x86_64"' latest.json
```
If the signature check does not print `Signature Verified Successfully`, or the hashes differ, do not run the file, and tell us. A signature proves the list came from the holder of the release key, not that anyone has audited the code. If you do not have openssl 3, the hash comparison alone still catches a corrupted or swapped download from the same place as the list, but not a list that was tampered with too. See [Verify a download](https://sophiastack.sophiaxt.com/verify).
Put the file in a folder of its own and open it.
* **Windows** may warn you the first time, because the program is not signed with a Microsoft certificate yet. After you have checked the hash, choose **More info**, then **Run anyway**.
* **Linux**: make it runnable first with `chmod +x sophia-linux-*`, then run it.
* **macOS**: the program is not notarized by Apple yet. In Terminal, run `chmod +x sophia-macos-aarch64` and `xattr -d com.apple.quarantine sophia-macos-aarch64`, then `./sophia-macos-aarch64`. The Mac build is new and we haven't tested it on a Mac yet. There is no build for Intel Macs yet.
It then:
1. Makes a `sophia-data` folder beside itself for your sites, pictures and settings.
2. Starts on the first free local port from 8806 up.
3. Opens the setup page in your browser.
Setup asks for your name, email and a password of at least 12 characters, then your site's name and a starting point: blank, business, blog, restaurant, or a bakery with a shop, a cake inquiry form and four pages, ready to make your own. When you finish you are signed in and looking at your new site in the admin.
The window that opened with it is the server. Close it, or press Ctrl+C, to stop. Open the program again to carry on where you left off.
## On a Linux server
Same three steps, with one command doing the first two. You need a 64-bit Linux server (Intel, AMD or ARM) with systemd and root access, plus a domain name pointing at the server. Run this as root, then open the setup link it prints:
```
curl -fsSL https://sophiastack.sophiaxt.com/download/install.sh | sudo sh -s -- --domain example.com,www.example.com --tls-email you@example.com
```
The installer:
1. Downloads the program and checks it against the signed release list, using the SOPHIA XT release key built into the script. Without openssl 3 it falls back to the published SHA-256. If a check fails, it stops and installs nothing.
2. Installs it under `/opt/sophia`, running as its own account in a locked-down systemd service that listens only on `127.0.0.1`.
3. Sets up nginx or Caddy in front for your domain, if one is installed.
4. Gets an HTTPS certificate from Let's Encrypt when you give `--tls-email`. Passing it accepts Let's Encrypt's terms.
5. Prints a one-time setup link. Until someone uses that link, the setup page turns everyone away, so a stranger who finds your address first cannot become the owner.
Useful options:
| Option | What it does |
| --- | --- |
| `--domain a.com,www.a.com` | Names to serve. Without it, only `127.0.0.1` reaches the site. |
| `--tls-email you@a.com` | Get an HTTPS certificate with certbot (nginx). Caddy handles HTTPS itself. |
| `--install-proxy` | Install nginx and certbot when the server has no web server. |
| `--proxy nginx\|caddy\|none` | Choose the web server, or leave it alone with `none`. |
| `--behind-https` | Something else in front (a load balancer, Cloudflare) already provides HTTPS. |
| `--http-port 8806` | The local port the program listens on. |
| `--name sophia` | The service and account name. Use another name to run a second install. |
The installer never changes a web server setting for a domain another site on the server already uses. It tells you instead. If nginx or Caddy rejects the new settings, it takes them back out.
If you run your own web server in front, send requests to `127.0.0.1:8806` and set the `X-Real-IP` header to the visitor's address. Sign-in limits and spam checks count by it.
## Updating
On a server, as root:
```
sudo /opt/sophia/current/sophia update --latest
```
This fetches the list of the newest files and checks its signature against the SOPHIA XT release key built into every copy of the program. Then it downloads the new program and checks that its SHA-256 matches the signed list. If either check fails, nothing changes.
The update stops the service, copies the database, switches to the new version and waits for it to answer. If it does not answer within 30 seconds, the previous version and that database copy come back by themselves. Three versions and three database copies are kept.
On your own computer, download the new file and open it in place of the old one. Your `sophia-data` folder stays where it is.
## Checking a download yourself
[Verify a download](https://sophiastack.sophiaxt.com/verify) shows how to check the signed release list with openssl, then check any file, including the installer script, against it before you run anything.
## Moving a site you built on your computer
If you have the developer setup (see [Deploying](https://sophiastack.sophiaxt.com/docs/deploy)), `sophia deploy` sends your sites, pictures and accounts to a server over ssh in one command. Otherwise, back up under **This install > Security** and restore the backup on the server.
---
# License | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/license
# License
Sophia Stack X is free to use. You can run it on as many computers and servers as you like and build any kind of site with it, including paid work for clients. You don't need to register or pay.
The program itself belongs to SOPHIA XT LLC. It isn't open source: you may not sell or repackage the program, change the program file, or take it apart.
What you make with it is yours: your content, your data, and the extensions, templates and sites you build. You may sell those. Sophia Stack X doesn't send your content or data to SOPHIA XT. It contacts the download site only when you ask it to check for an update.
## Read the full text
* [LICENSE.txt](https://sophiastack.sophiaxt.com/download/LICENSE.txt), the license itself
* [THIRD-PARTY-NOTICES.txt](https://sophiastack.sophiaxt.com/download/THIRD-PARTY-NOTICES.txt), the open-source libraries built into the program and their licenses
Every copy of the program carries both. Run `sophia license` to print the license, and `sophia license --third-party` for the notices.
## In short
| You may | You may not |
| --- | --- |
| Run it on any number of machines, free | Sell, rent or sublicense the program itself |
| Build sites and apps for yourself or clients | Change, decompile or reverse-engineer the program file |
| Charge clients for sites, hosting, design and support | Remove its copyright or license notices |
| Write and sell your own extensions and templates | Suggest SOPHIA XT made or endorses your product |
| Share the official download link | Pass on altered copies |
## Free, but not open source
**Can I use it for paid client work?** Yes. No fee, no registration, no limit on sites or servers.
**Can I read or fork the source?** Not under this license. You can't publish your own builds or ship a changed copy.
**How do I know what I'm running?** Every download is on a list signed with the SOPHIA XT release key, and the installer and the updater both check it. [Verify a download](https://sophiastack.sophiaxt.com/verify) shows how to check it yourself. The open-source libraries inside, and their licenses, are in [THIRD-PARTY-NOTICES.txt](https://sophiastack.sophiaxt.com/download/THIRD-PARTY-NOTICES.txt).
**What if my company needs a source review or other terms?** Contact SOPHIA XT LLC through [sophiaxt.com](https://sophiaxt.com).
**What happens to my sites if Sophia Stack X stops?** Your sites are published as plain HTML files, and every page also has a Markdown copy. You can serve them with any web server, and your content sits in one SQLite database file you control.
The software comes without warranty, as described in the license. For other terms, such as redistribution or access to the source, contact SOPHIA XT LLC through [sophiaxt.com](https://sophiaxt.com).
---
# Marketplace | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/marketplace
# Marketplace
Templates, apps and blocks you can add to any Sophia Stack X site. Each one is reviewed by SOPHIA XT before it is listed, and each install is checked against a catalog we sign, so a package changed on the way never reaches your site.
## Hearth
An editorial bakery template: a big serif headline on a warm cream page, a bakery hero and a story block, and pages ready for the shop, a menu and cake inquiries. It was built by an outside AI agent test as a complete bakery site, using the normal shop and forms. Free.
* Template, version 0.1.1
* Two blocks: bakery hero and bakery story
* Colors in the Design screen, with contrast checks
* Asks for no permissions

## Install one
In the admin, open a site's **Extensions** and choose **Get more from the marketplace**. Installing needs a super user, because an extension is added for the whole install. Apps and blocks are switched on for that site straight away. A template is then chosen under **Settings**.
From a terminal:
```
sophia market-list
sophia market-install hearth
```
AI agents use the `market_list` and `market_install` MCP tools. Installing works only for a local agent, not one connected with a site token.
## How a package is checked
The catalog at [/market/catalog.json](https://sophiastack.sophiaxt.com/market/catalog.json) is signed with the SOPHIA XT release key, the same key that signs the program's own updates, and every copy of the program carries the public half. Each entry names the package's SHA-256 and the key its publisher signed it with. An install refuses a package unless:
1. the catalog's signature checks out;
2. the downloaded package matches the SHA-256 in the catalog;
3. the package's own signature checks out with the publisher key the catalog names;
4. its name and version are the ones listed.
The publisher's key is not added to your install's trusted keys. The catalog vouches for that one package and nothing else. Anyone can check the catalog with openssl, the same way as [a download](https://sophiastack.sophiaxt.com/verify):
```
openssl pkeyutl -verify -pubin -inkey release-key.pem -rawin -in catalog.json -sigfile catalog.json.sig.bin
```
## List your own
Build your extension (see [Building extensions](https://sophiastack.sophiaxt.com/docs/extensions)), sign it with your own key using `sophia keygen` and `sophia pack`, and check it with `sophia check`. While we review the first listings, the marketplace is by invitation. Paid listings come later.
---
# A CMS written in Rust, shipped as one program | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/rust-cms
# A CMS written in Rust, shipped as one program
# A CMS written in Rust, shipped as one program
Most content management systems are a stack: a language runtime, a database server, a web server and a pile of plugins that each need patching. Sophia Stack X is a CMS written in Rust that ships as one executable. That program is the admin, the web server, the site builder and the package tool. Its database is a SQLite file it makes for you.
This page explains what that means in practice, what Rust does and does not buy you here, and what you give up.
## What is in the program
One file, `sophia`, does the work of several parts:
* **The admin.** A page builder with a live preview, a Design screen for colors and fonts, a Publish screen, an Import screen, accounts, backups and an audit log.
* **The web server.** It answers on its own port and picks a site by host name, so one install can serve several sites. On a server it sits behind nginx or Caddy, or the installer sets that up.
* **The build system.** Publishing renders every route into a numbered release of plain files and checks links first.
* **The package tool.** Extensions are built, checked and signed with the same file: `sophia new`, `sophia check`, `sophia pack`.
* **An MCP server.**`sophia mcp` gives AI agents 55 tools to work on the site. See [a CMS AI agents can run](https://sophiastack.sophiaxt.com/ai-cms).
Everything else lives in one data folder: a SQLite database, uploaded files and published releases. Backup is `sophia backup`, and restore is `sophia restore`.
## What Rust gets you
The honest list is shorter than the marketing for most Rust projects, so here it is.
**One file to deploy.** Rust compiles to a native executable. The Linux build is fully static, so it runs on any 64-bit Linux without installing libraries. There is no PHP or Node to install, version or patch on the server.
**Small, steady memory.** On our test machine an idle server used about 13.5 MiB and 24 MiB under 32 connections on a published page. Those are our own numbers from one computer, with the method written out on the [benchmarks](https://sophiastack.sophiaxt.com/benchmarks) page.
**Memory safety.** Rust prevents whole classes of memory bugs in the program's own code. It does not remove other bugs, such as logic errors or a missing permission check. Security here also comes from design: the site visitors see is plain files, extensions are sandboxed, and updates must be signed. See [Security and backups](https://sophiastack.sophiaxt.com/docs/security).
**Fast start.** The server answered its first request about half a second after launch in our test.
What Rust does not give you: a library of ready-made themes, or a community the size of PHP's. That is the trade, and it is why extensions are JavaScript.
## Extensions in JavaScript, not Rust
You do not need to know Rust to extend Sophia Stack X. An extension is a folder with a manifest, templates and optional JavaScript that runs in a sandbox. The sandbox is a small JavaScript engine inside the program, with no Node, no npm and no build tool. The code can reach only the permissions its manifest declares, such as data or mail, and the site allows.
```
sophia new app tickets
sophia check extensions/tickets --json
```
The program checks the manifest, parses templates and compiles the script, then packs and signs it. The [extensions guide](https://sophiastack.sophiaxt.com/docs/extensions) has the manifest and the calls code can make.
## SQLite, on purpose
One database file means one thing to back up and nothing to run alongside. SQLite handles a lot of reading, and most of a site's traffic never reaches it, because visitors get the published files by default. Sites that need many writers at once, such as a very large shop, should look at the limits before choosing it.
## What you give up
* **It is not open source.** You can use it free for any site, including client work, and what you make is yours. You cannot read the source or fork the program. The [license](https://sophiastack.sophiaxt.com/license) has the details.
* **It is new.** The first version is 0.1.0, and the [changelog](https://sophiastack.sophiaxt.com/changelog) shows what shipped and when.
* **The ecosystem is small.** The [marketplace](https://sophiastack.sophiaxt.com/marketplace) lists packages reviewed by SOPHIA XT. There is no directory of thousands.
* **Self-hosted.** You run it. SOPHIA XT does not host it for you.
* **The Windows program is not code-signed yet,** so Windows may warn on first run. [Verify a download](https://sophiastack.sophiaxt.com/verify) shows how to check it.
## Try it
You can run it in about two minutes. [Download the program](https://sophiastack.sophiaxt.com/install), open it, and fill in one setup page. Or try a private bakery site in the [live demo](https://demo.sophiastack.sophiaxt.com/demo/start) for an hour, with nothing to install. If you are weighing it against something you know, read the [comparison with WordPress, Joomla and Ghost](https://sophiastack.sophiaxt.com/compare). If you plan to run it on your own server, see [a self-hosted CMS](https://sophiastack.sophiaxt.com/self-hosted-cms).
---
# A self-hosted CMS you can run from one file | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/self-hosted-cms
# A self-hosted CMS you can run from one file
# A self-hosted CMS you can run from one file
Self-hosted means you run the software on a machine you control, and your content stays there. Sophia Stack X is built for that. It sends no content or data to SOPHIA XT. It contacts the download site only when you ask it to check for an update.
This page covers what you need, how installing and updating work, what you are responsible for, and how to leave if you want to.
## What you need
On your own computer: Windows 10 or 11 (64-bit), a 64-bit Linux machine (Intel, AMD or ARM), or a Mac with Apple silicon. Download the file, open it, and fill in one setup page. It makes a `sophia-data` folder beside itself and opens the setup page in your browser.
On a server: a 64-bit Linux server with systemd, root access, and a domain name pointing at it. One command does the rest:
```
curl -fsSL https://sophiastack.sophiaxt.com/download/install.sh | sudo sh -s -- --domain example.com --tls-email you@example.com
```
The installer downloads the program and checks it against the signed release list. It then installs it under its own account in a locked-down service that listens only on `127.0.0.1`, sets up nginx or Caddy for your domain, gets an HTTPS certificate when you give it an email, and prints a one-time setup link. Until someone uses that link, the setup page turns everyone away, so a stranger who finds your address first cannot become the owner.
Prefer to read the script before running it? The [Verify a download](https://sophiastack.sophiaxt.com/verify) page shows how to fetch it, check its signature, and run it only if it matches.
## There is no database server and no runtime
The program is the web server, and the database is one SQLite file. You do not install PHP, Node or MySQL, so there are none of them to patch. The live site is plain files, with the admin served by the same program.
## Updates you can check
Updating on a server is one command, run as root:
```
sudo /opt/sophia/current/sophia update --latest
```
It fetches the list of the newest files and checks that the list is signed with the SOPHIA XT release key built into the program. Then it downloads the new version and checks its SHA-256 against the signed list. If either check fails, nothing changes. If the update works, it stops the service, copies the database, switches versions, and waits for the new one to answer. If it does not answer within 30 seconds, the previous version and the database copy come back by themselves. Three versions and three database copies are kept.
## Backups and rollback
**Back up now** in the admin, or `sophia backup`, writes one zip with a consistent copy of the database, every site's pictures, installed extensions, trusted keys and settings. Fourteen are kept by default. To restore, `sophia restore --into `, then start the program with `--data `.
For content mistakes, publishing makes numbered releases. The last ten are kept and any of them goes live again in one click. If you let an AI agent work on the site, it can publish and roll back through the same releases.
## What you are responsible for
Self-hosting is a trade. We can say plainly what falls on you:
* **The server.** Operating system updates, firewall, disk space and the domain's DNS.
* **Backups kept off the machine.**`sophia backup` makes the zip, but copying it somewhere else is your job.
* **Your sign-ins.** Turn on two-step sign-in. **This install > Security** lists what still needs doing before a site is public.
* **Email delivery.** A site that sends mail needs a mail account. Setup has presets for common providers.
* **Updates.** Nothing updates itself without you running the command or republishing on your schedule.
SOPHIA XT does not host your site or run it for you. The [changelog](https://sophiastack.sophiaxt.com/changelog) states the support policy.
## Security by design
The site visitors get is published files by default. On a server, the program runs as its own user, can write only its data folder, and listens only on `127.0.0.1` behind your web server. Passwords are stored with Argon2, sign-in attempts are slowed down, and every change by a person or an AI agent goes in the audit log. Extensions are sandboxed and get only the permissions they declare. [Security and backups](https://sophiastack.sophiaxt.com/docs/security) has the full list.
## Leaving
You can walk away. Your sites are published as plain HTML files, and every page has a Markdown copy. Any web server can serve them, and your content sits in one SQLite database file you control. The program itself is free to use for any site but not open source, so the admin and updates stop if you stop using it. The [license](https://sophiastack.sophiaxt.com/license) explains the terms.
## The cost
Sophia Stack X is free for any site, including paid work for clients, on any number of computers and servers. You pay for the server and domain you choose. Compare it with WordPress, Joomla and Ghost on the [comparison page](https://sophiastack.sophiaxt.com/compare).
## Next step
Pick one: [install it](https://sophiastack.sophiaxt.com/install), [try the live demo](https://demo.sophiastack.sophiaxt.com/demo/start) without installing, or read how [deploying from your computer](https://sophiastack.sophiaxt.com/docs/deploy) works.
---
# Templates | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/templates
# Templates
Every template styles the whole site: pages, the blog, the shop and forms. Each one has presets and a Design screen where you change colors, fonts, sizes and buttons with a live preview, and text that would be hard to read is refused before it saves. Switch between them under **Settings**: your pages, articles and products stay as they are. A block that belongs to one template, such as Glass's screen tour, shows only while that template is in use.
Six come with every copy. Hearth is in the [Marketplace](https://sophiastack.sophiaxt.com/marketplace).
## Nova
A dark space look for software, launches, agencies and anything that should feel new: a starry grid behind everything, headlines in a cyan, blue and violet gradient, frosted glass cards, glowing buttons and a tilted frame for product screenshots. It pairs with the section library, so a whole landing page goes together in minutes.
* Presets: nova (cyan, blue and violet), aurora (mint and teal), nebula rose, solar (amber and coral), deep blue
* Works with section effects: glass, glow shadows, wave dividers and entrance motion

## Trade
For local service businesses: contractors, plumbers, electricians, landscapers, cleaners, salons and clinics. A tap-to-call number in the header, a call bar that stays on screen on phones, service tiles, testimonials and a quote form built to be filled in.
* Presets: navy and safety orange, night shift, green trades, clinic blue, black and yellow
* Settings for the phone number, hours and service area

## Studio
For designers, photographers, architects and small agencies. Large headlines, quiet colors with one accent, picture-led project cards and motion that settles as you scroll.
* Presets: studio, gallery white, editorial serif, sage, darkroom, gallery black
* Card shape, section spacing and headline weight on the Design screen

## Journal
For writers, newsletters, magazines and nonprofits, where reading comes first. Serif text at a comfortable line length, the newest article set large, reading time, drop caps, pull quotes and a signup panel.
* Presets: paper, night reading, sepia, newsprint, harbor blue
* Line length, text size, drop cap and end mark on the Design screen

## Aurora
The default. Engineered and fast, with nine module positions, a sidebar and an accent color. A good start for a business site, documentation or anything you want to shape yourself.
* Presets: Aurora, Harbor, Ember, Grove, Night

## Glass
Dark glass panels over a lit lattice, for software and product sites. Screenshots in window frames, a screen tour, feature grids and an install panel. This site uses it.
* Its own blocks: glass hero, feature grid, screen tour, split, marquee and install panel

## Hearth
An editorial bakery template with its own hero and story blocks, in the Marketplace. The bakery starter in setup and in the demo workspace uses it.
* Install: Extensions, then Get more from the marketplace, or sophia market-install hearth

## Try one
[Build a bakery in a private workspace](https://demo.sophiastack.sophiaxt.com/demo/start) and change its colors, fonts and buttons on the Design screen, or [install](https://sophiastack.sophiaxt.com/install) and pick any of these on the setup page. To make your own, start with `sophia new template ` and see [Building extensions](https://sophiastack.sophiaxt.com/docs/extensions).
---
# Verify a download | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/verify
# Verify a download
Every release has one list, `latest.json`, that names each file and its SHA-256. SOPHIA XT signs that list with an Ed25519 key. Check the signature once, then check any file against the list. If both match, the file is the one we published.
The release key is:
```
1d6b0c095ceca8b2e6ca84c4cc11413fc6906fb5384b9e703ed98e2a98cd0a22
```
It is built into every copy of the program and into `install.sh`. The same key, in the form openssl reads, is at [/download/release-key.pem](https://sophiastack.sophiaxt.com/download/release-key.pem).
## On Linux, before running the installer
You need openssl 3.0 or newer (`openssl version`).
```
B=https://sophiastack.sophiaxt.com/download
curl -fsSLO $B/install.sh -O $B/latest.json -O $B/latest.json.sig.bin -O $B/release-key.pem
# 1. The list is signed by SOPHIA XT. Prints "Signature Verified Successfully".
openssl pkeyutl -verify -pubin -inkey release-key.pem -rawin -in latest.json -sigfile latest.json.sig.bin
# 2. The script matches the list. The two hashes must be the same.
sha256sum install.sh
grep -A1 '"install.sh"' latest.json
# 3. Read it, then run it.
less install.sh
sudo sh install.sh --domain example.com --tls-email you@example.com
```
Compare the key inside `release-key.pem` with the key above if you got the file from the same place as the download. `install.sh` then repeats the same checks for the program it downloads.
## Checking a program
Do steps 1 and 2 with the program's file name in place of `install.sh`:
```
sha256sum sophia-linux-x86_64
grep -A1 '"sophia-linux-x86_64"' latest.json
```
On a Mac, use `shasum -a 256` in place of `sha256sum`. The openssl that ships with macOS can't check Ed25519 signatures; check the signature on any machine with openssl 3, then compare hashes on the Mac.
On Windows, in PowerShell:
```
Get-FileHash sophia-windows-x86_64.exe -Algorithm SHA256
```
Compare the result with the entry in `latest.json`.
## What the signature does and doesn't cover
A good signature means the list came from whoever holds the SOPHIA XT release key, and the matching hash means the file is the one on that list. It does not mean an outside party has audited the code. The open-source parts are listed in [THIRD-PARTY-NOTICES.txt](https://sophiastack.sophiaxt.com/download/THIRD-PARTY-NOTICES.txt).
Updates use the same check: `sophia update --latest` refuses any list that is not signed by the key built into the program, and any program that does not match the list.
---
# A WordPress alternative with one program and no plugins to patch | Sophia Stack X
Source: https://sophiastack.sophiaxt.com/wordpress-alternative
# A WordPress alternative with one program and no plugins to patch
# A WordPress alternative with one program and no plugins to patch
WordPress runs a huge share of the web for good reasons: it is open source, it has an enormous ecosystem, and almost every host knows it. If you are thinking about leaving, you probably have a specific reason. This page is for people whose reason is one of these: a stack to keep patched, plugins that need constant updates, a site that is slow to edit safely, or a wish to let AI agents help without handing them the keys.
Sophia Stack X is a self-hosted CMS in one program. It is new, it is not open source, and it will not replace WordPress for every site. Here is where it differs, and how to move.
## What is different
**One program instead of a stack.** Sophia Stack X is one executable with a SQLite database file it makes for you. There is no PHP, no MySQL and no web server to configure on your own computer. On a server the installer sets up the service, nginx or Caddy and HTTPS. See [a self-hosted CMS](https://sophiastack.sophiaxt.com/self-hosted-cms).
**Built in, not bolted on.** Page builder, SEO tools, forms, comments, events, a shop with Stripe checkout, booking, a newsletter, visitor stats without cookies and email are switched on, not installed from a directory. Many small business sites need no extra extension.
**Extensions in a sandbox.** WordPress plugins are PHP that runs inside the application. Sophia Stack X extensions run in a sandbox and can reach only the permissions their manifest declares. Packages and the marketplace catalog are signed. You will find fewer of them, since every listing is reviewed by SOPHIA XT. See the [marketplace](https://sophiastack.sophiaxt.com/marketplace).
**A published site that is plain files.** Publishing renders a numbered release of HTML, checks links, and keeps the last ten. If a change goes wrong, any earlier release is live again in one click. Visitors get those files by default, and the files work on any web server.
**AI agents with guardrails.** An MCP server is built in, with 55 tools. An agent works in drafts, previews, dry runs and rollbacks, and every call is logged. See [a CMS AI agents can run](https://sophiastack.sophiaxt.com/ai-cms).
## What you give up
Honesty matters more than a sales page.
* The ecosystem. WordPress has an enormous number of plugins and themes, and Sophia Stack X has six templates and a small marketplace.
* Open source. You can use Sophia Stack X free for any site, including client work, but you cannot read or fork the code. The [license](https://sophiastack.sophiaxt.com/license) has the details.
* Maturity. This is version 0.1.0. The [changelog](https://sophiastack.sophiaxt.com/changelog) shows what has shipped.
* Hosting options. It is self-hosted. There is no managed hosting from SOPHIA XT, and fewer agencies will know it.
* Some plugin features. If your site depends on a plugin with no built-in equivalent, check before you move. The [WordPress walkthrough](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress) lists what comes over.
The [comparison page](https://sophiastack.sophiaxt.com/compare) puts WordPress, Joomla and Ghost next to Sophia Stack X, row by row.
## How to move a WordPress site
The importer reads the export file from WordPress (Tools, Export, All content) and brings over:
* pages and posts with dates, authors, categories and tags, with drafts and private posts as drafts
* the pictures those pages use
* menus and the home page
* WooCommerce products with sale prices, stock, galleries and variations
* approved comments with their replies
Every old address answers with a 301 redirect to its new page, and links inside the text are repointed. The importer removes plugin shortcodes and lists them in a report. It does not bring custom post types from plugins or your theme.
You can run a dry run that writes nothing:
```
sophia import export.xml --as my-site --name "My site" --dry-run
```
Then import for real, look over the result, check your most important old addresses, and switch your domain only when you are satisfied. The full set of steps, with the checks, is on [Migrate from WordPress](https://sophiastack.sophiaxt.com/docs/migrate-from-wordpress).
## What does not change
Your content stays yours. Your sites are published as plain HTML files with a Markdown copy of every page, and your content sits in one SQLite database file you control. If you ever want to leave, the files are ordinary. The license says what you make is yours and states what you may and may not do with the program.
## Who this suits
* A small business owner who wants a working site in a couple of minutes and a booking or shop switched on, without a plugin hunt.
* A freelancer or studio who builds sites for clients and wants to charge for the work, not a license. It is free for client work.
* A developer who would rather write a sandboxed extension in JavaScript than maintain a PHP plugin.
* A team that wants AI agents to help with the site while every change is a draft, previewed and logged.
## Next step
Try it first. [Open the live demo](https://demo.sophiastack.sophiaxt.com/demo/start) for a private workspace with a bakery site, or [download the program](https://sophiastack.sophiaxt.com/install) and run the importer against your own export. The two-minute setup is on the install page, along with the steps to [verify the download](https://sophiastack.sophiaxt.com/verify).