WordCamp Companion is a tool to plan your WordCamp and guide you through it, as well as for taking notes during sessions.

It is built as a WordPress plugin which you can install to your own WordPress (not in the plugin directory yet so you need to download the ZIP) or use through my.wordpress.net that I talked about in my previous posts.

Use this link to start it directly in my.wordpress.net. Since it is a WordPress hosted in your browser, it is free and private.

The plugin features:

• A live updating timeline with easy adding of sessions,
• Note taking for each session with export,
• Sharing sessions to others,
• AI Assistant compatibility.

Scroll down to find screenshots and screen recordings of those features.

Let’s start with timeline view. It will automatically update according to the current time and show you when to switch tracks.

Adding Sessions

In the timeline you can see an “Add a session” in the gaps of your schedule.

Note Taking

You can take notes inline in Markdown-style which you can then export.

Session Sharing

All WordCamps

While it is good timing for WordCamp Europe, it also works for multiple (future) WordCamps:

AI Assistant Compatible

I’ve been working on a capable AI Assistant for WordPress that you can try inside my.wordpress.net. It can help you work out a schedule:

If you’re attending this WordCamp Europe, or other future WordCamps, give the WordCamp Companion a try. You can do it easily and risk-free with this link to start it directly in my.wordpress.net.

I think today every developer who is jumping on the AI train experiences it themselves: they can suddenly scratch many of their own software itches with a quick prompt.

Of course, developers are more likely to think of software-driven solutions to real-world problems than non-developers. But as creating apps gets easier, that instinct may spread beyond developers too, as the Verge article describes.

That is exciting. But I think the more interesting question is not only “who writes the code?” It is: where does this personal software live?

Already before this AI revolution, developers built software using their favorite stack. That’s what they are fastest in, that’s a setup where they run their other self-developed software already. And this leads to what I call the self-hosting chaos:

Yes, there is Docker as a solution to run any stack on any machine but it’s really a developer tool. And while there are solutions like Instapods which I applaud for its effort to try and make it easy, as a user, every tool still has its own setup flow.

And then there are questions like: Where is the data stored? Can I export it? Do I need another host for a second app?

It might be a surprising angle but this is where I think WordPress has an interesting role to play, and I’ve been working on making this even more feasible recently.

The fact that it’s a widely used software for blogging has the side-effect that it’s easy to find hosting for it anywhere you like. So, what if you don’t use it for blogging, but as a personal app platform?

This needs a reframe of people’s thinking, and I wrote about it just recently. But once you let it sink in, WordPress is a pretty decent platform for personal apps, providing lots of things out of the box:

• Easy plugin installation,
• User accounts and permissions,
• Media library,
• Posts, pages, custom post types, and taxonomies,
• REST APIs,
• Import/export,
• Widely available hosting.

Ok, if you send someone to wp-admin and ask them to install an app, that would be overwhelming. But with the right tooling to guide the user, we can make this real easy.

While the final destination would be a hosted WordPress somewhere, there is my.wordpress.net which is a free, hosted-in-the-browser WordPress where you can give it a go without registration.

You’ll arrive in an app launcher-like screen:

And the Add button takes you to an “App Store” with apps pre-selected for the yet-uncommon use case of “personal software.”

Granted, the selection of apps is still limited but this is mostly an effort to kickstart the ecosystem for this use case, while at the same time having some really useful apps that go beyond a simple prototype.

Recipes aim to give you more concrete ideas of what you can do:

For example, personally, I’ve been enjoying storing my recipes in my WordPress. Some are recipes passed down through family generations. Others are ones I had cherry-picked from the web, then later had to remember which blog I had found them on when I wanted to cook them again.

And while “AI Assistant” is quickly becoming an overused concept, I really like how it can not only work with those apps (“I’m trying to eat vegan today, give me a variation of the recipe (I’m currently looking at)”) but also how it can work across app boundaries because they all live in my WordPress (“My friend recently blogged about recipe X, please add it to my cookbook and put it on my meal plan for tomorrow”).

Granted, you need to provide your own API key or run Ollama or LM Studio locally (I hope this will get better some day!), but then it can even build the apps you wish for right there as a new plugin that you can then download and share.

WordPress as the Personal App Platform

But back to the point about the platform for apps:

I think WordPress is so great because installing an app is as easy as installing a regular WordPress plugin (if not easier, with the My Apps plugin screenshotted above).

And for developers, there is this place where all your apps can run, with nice features out of the box, and honestly, AI doesn’t care much in which programming language they implement your dream software. Even PHP.

I’ll just admit that my.wordpress.net is my work, so I am biased. But I believe there is real merit in building the future of personal software on the benefits of the legacy of open source WordPress. It was built for one weird use case twenty years ago. It might quietly turn out to be built for the next one too.

That work has added up to something I’d call a coherent vision. And now, with my.wordpress.net, I believe I have contributed to tearing down one of the last walls that have been blocking people from joining me in this experience.

The wall

I have created many of the plugins I’m going to describe already some while ago. They’ve found an audience, but admittedly inside a bubble: people who already had a WordPress, or were technical enough to spin one up just to try something.

To try a plugin that makes WordPress personally useful, you first need a WordPress. And setting one up means finding a host, picking a domain, making decisions about a site you’re not even sure you want yet. That’s a publishing commitment, and most people won’t make it just to see if a feed reader or a personal CRM might be useful to them.

That’s the wall I kept running into. And that’s why I built my.wordpress.net: a complete WordPress that runs in your browser, no sign-up, no hosting plan, no domain needed.

It just behaves like a normal WordPress: you change something, you come back tomorrow, it’s still there. Persistent, and private by default.

Which sounds obvious because that’s how a website is supposed to work. But it’s built on WordPress Playground, a developer tool that is fresh and forgetful by design, because that’s useful when you’re testing things. And if you’re a developer: don’t worry, playground.wordpress.net will remain.

What your personal WordPress can do

Once you have a WordPress that’s yours rather than your audience’s, a whole different set of questions becomes interesting.

Keeping memories. When our first child was born, we wanted to keep a diary. We wanted more than just collecting the photos and videos, we wanted to have a place where we could also write down the stories, the funny things they say, messages in a bottle to them later on. A private blog was the perfect solution for that. And later, with Enable Mastodon Apps, we started using a nice mobile Mastodon app to do it, and grandparents to follow along, who would have thought of that?

Gathering memories. My daughter had a ski day recently. Photos came in from several different group chats: parents, the teachers. Before Chat to Blog, I would have to save them each and reupload them to my WordPress. But since I can now privately connect it to Beeper (a messaging client that can talk to Signal, Whatsapp, etc), it allows me to put the media directly into a new post and the media library, without any forwarding or downloading. The chat messages can disappear someday and it won’t matter, I still have the blog post.

Staying in touch. There are people in my life I genuinely care about, where things have faded a little; not because either of us stopped caring, but just because everyone has a busy life. Sometimes all it would take is a reminder to send a quick hello. Personal CRM turns WordPress into a private contact directory for the people who matter to you. Combined with Keeping Contact, it tracks when you last reached out and reminds you when it’s been too long. It’s not a sales tool. It’s just the nudge to actually do it.

What are you reading? The Friends plugin makes WordPress a feed reader: follow RSS feeds, Atom feeds, ActivityPub accounts. Everything you chose to follow in one timeline, without any algorithm deciding what to surface. Friends 4.0 added three themes: a Google Reader-style interface with keyboard shortcuts (for those who never quite got over losing it in 2013), a Mastodon-style view for people already at home in the Fediverse, and a Block Theme option that integrates with your site’s own design. On a hosted WordPress, you can also participate in the Fediverse directly: follow and be followed, post to your own site and have it federate to Mastodon; and with Enable Mastodon Apps, you can use any Mastodon client to do it.

What articles did you save and actually read? Post Collection clips articles from the web into your WordPress. Send to E-Reader routes them to your Tolino or Kobo, Kindle or Pocketbook, so the things you saved are the things you actually end up reading, just maybe on a different device on which you saved them.

Keeping family history. I’ve always enjoyed hearing the little anecdotes from my family, but I wish I’d have a better memory for them. Thus I started keeping a private family wiki where the we collaborate in maintaining a Wikipedia for our family. It feels great to have this family chronicle to pass on.

Longevity. Right now, in my family, I am the most technical person. What will happen to all those memories in our WordPress? To make sure all those stories can persist, I created Static Archive which turns backups into easily accessible treasure troves. It works by keeping an HTML copy of your posts (and wiki pages) with inline media in your uploads folder, automatically updated every time you publish. It’s not a typical static site generator, it just quietly maintains an archive that is always current.

What do you want to ask your own data? The AI Assistant empowers you to modify your WordPress through chat. It can create or modify plugins to your liking, theme your site, interact with plugins through abilities that they provide. It pulls AI into your WordPress instead of interacting with it from the outside. This supports local models (for example through LM Studio) as well as OpenAI and Anthropic if you can provide an API key.

When announcing My WordPress and also inside my.wordpress.net, we’re using the metaphor of an app because they work like a web app, just hosted on your own WordPress. For the technically inclined: they are indeed plugins, but sometimes multiple working together, installed already configured through a blueprint.

What this is really about

WordPress is a widely available piece of open source software: you have a vast choice of hosts, or you can even install it on your local NAS (they usually already allow to install WordPress easily). While there are many tools that you can already self-host, each needs individual knowledge to set them up correctly. WordPress can be this one platform that can run all your apps, making it much more accessible.

The plugins I mentioned before have a few things in common. Your data lives on your WordPress: contacts, reading lists, saved articles, conversation history. They are not locked into someone else’s service where maybe you can get them out with a data export request, in a format of their choice.

But instead, everything lives in one place, and you (or a plugin) can combine it however you want, without involving anyone else.

You can modify your WordPress like you want: have plugins created for your needs, modify existing ones to your liking. With AI this is now becoming much more feasible for anyone.

And finally, this is all free and open source. No subscriptions, no per-user fees. You can run the software yourself, for as long as you want.

Getting Started

my.wordpress.net can be your starting point. It has its limitations and you might outgrow them. Because it’s a browser-based WordPress, it can reach out to the web to fetch feeds, clip articles, call APIs. But the web can’t reach in: ActivityPub federation, being followed by others, multi-device access: these need a reachable server.

But that’s just a natural progression: You start in the browser, discover what you actually want from a personal WordPress, and transfer to a webhost when the networked features become worth it.

And if you already have a WordPress, all of this is for you too. Skip my.wordpress.net and proceed to taking back the web for yourself straight away.

Focusing on ActivityPub

The biggest change is a deviation from the original idea: Friendships between WordPresses have been removed. With ActivityPub (when the respective ActivityPub plugin is installed, too) we have a communication protocol that is supported by many more platforms than just other WordPresses that also happen to have installed the Friends plugin.

Removing friendship functionality reduces a lot of complexity in the plugin that changed some fundamentals of WordPress. The friendship functionality had been deactivated for a while behind a checkbox.

This means that the Friends plugin now focusses on functionality of subscribing to feeds (be it RSS, Atom or ActivityPub) and integrating outward communication via ActivityPub (direct messages, replies).

Themes

To make the consuming more attractive, I have worked on providing more integrated themes. I had added the ability to contribute themes already some time ago, thanks for the FediPress theme contribution! Being more a developer than a designer, my default Friends theme has been deemed more functional than pretty (from what I heard).

So, the new themes are:

A Block Theme, which allows you to modify the Friends page using the Site Editor and gives it the design of your own site’s theme.

A Google Reader Theme makes it look like Google Reader. This comes with keyboard shortcuts and the accordion-like behavior of the posts.

I had already done a prototype of a Mastodon Theme and have now added a functional one that is shipped by default.

All the themes now support light and dark mode (which makes the Mastodon theme look a bit unusual in light mode).

I hope that the screenshots above highlight the versatility of the plugin and how much the visual appearance can shape the perception.

Migrations

A big reason for the 4.0 version number was the number of migrations of internal data structures towards more taxonomies (the Friends plugin did not and does not use custom tables). This removes the last bits of supporting WordPress users as friend users and adds proper term relationships between friends and subscriptions. This also allowed to add support for folders.

But it makes a transition from an earlier version potentially a bit tricky. With this amount of changes and migrations, I opted to make it easier to discover what’s new and what is already migrated. I hope that all migrations go smoothly but if they don’t, this gives you insight into where things might be stuck.

The amount of necessary fundamental changes and migrations made this release somewhat risky and was a reason for the long time since the last release. I am hoping that with these changes now shipped, I can provide more frequent updates again!

Oh, I also shipped a new version of the Enable Mastodon Apps plugin (1.5.0) which makes use of some of the taxonomy changes in Friends that now allow to distinguish between mentions and direct messages, and there should be a speed-up in many endpoints, especially the notifications endpoint.

Enjoy this new release, which I hope will make it easier and more feasible to use Your WordPress as Your Personal Mastodon Instance.

But what if you could just fix it right there?

With AI coding assistants that run in the browser—like Claude Code, OpenAI Codex, GitHub Copilot Workspace, or similar tools—combined with WordPress Playground for testing, you can now do WordPress plugin development without a computer.

What It Looks Like

AI: I’ve implemented the fix for you, committed and pushed it to Github. Use this link to Test it in WordPress Playground.

This link above just leads to a generic Playground but to give you an idea of the workflow: The AI helps you fix or implement what you asked for and makes the code available in a branch. You’ll then run/view it via Playground. Here’s how to set this up:

What You Need

• Your plugin or theme in a GitHub repository,
• A web AI coding assistant,
• A way to tell the AI how to generate Playground test links that you can click.

The third part is where the Playground Step Library comes in.

Step 1: Create Your Blueprint

WordPress Playground uses blueprints: JSON configurations that describe what to install and how to set things up. You can install plugins, themes, configure settings, import content, and more. Writing these by hand is a little cumbersome, so I built the Step Library as a visual tool to assemble blueprints step by step.

The Step Library also provides more steps than Playground offers natively: that’s where the name comes from. It compiles these custom steps into the native steps that Playground understands. The native steps are powerful but require you to know how to combine them in clever ways; the Step Library’s custom steps make it easier. Examples include addProduct for WooCommerce, addTemplatePart for block themes, a debug step to enable common debug settings and plugins, or disableWelcomeGuides.

Use this special link to the Step Library to start with an “Install Plugin” step. Paste your HTTPS GitHub repository URL. If you want to test a specific branch, add /tree/branch-name to the URL—but for now, just use your main branch. We’ll make the branch dynamic later.

Add any other steps your testing environment needs: maybe WooCommerce if your plugin integrates with it, or some test content, or specific WordPress settings.

Step 2: Generate AI Instructions

Once your blueprint is ready, open the “Copy/Share” dropdown and select “Generate AI Instructions”. This creates a markdown snippet you can add to your project’s CLAUDE.md, .github/copilot-instructions.md, or similar AI instruction file:

The generated instructions tell the AI to include a Playground testing link at the end of its responses. The branch name in your URL gets replaced with a BRANCH_NAME placeholder, so the AI knows to substitute the actual branch it’s working on.

Step 3: Add to Your Repository

Copy the generated markdown and add it to your AI instruction file. Commit it to your repository. Now any AI assistant that reads these instructions will include Playground links when it makes changes to your code.

Bonus: you can also instruct your coding assistant to add such a file to your repo!

The Workflow

Here’s what this looks like in practice:

1. Open your AI coding assistant on your phone (or desktop),
2. Connect to your GitHub repository,
3. Describe what you want to change or fix,
4. The AI makes the changes and pushes a branch,
5. Tap the Playground link in the response,
6. Test the changes in Playground—if it’s a private repo, you’ll authenticate with GitHub here,
7. If it works, create a PR and merge it—you got to test before even opening the PR.

It’s a complete development loop. The AI handles the code, GitHub handles version control, and Playground handles testing. Your phone is just the interface tying it all together.

Private Repositories

Until recently, this workflow only worked with public GitHub repositories. I submitted a PR to WordPress Playground that adds GitHub OAuth authentication. Now when you load a plugin from a private repository, Playground prompts you to authenticate, and then it works just like public repos.

Beyond Mobile: Preconfigured Test Environments

The mobile workflow is a fun demo, but the same setup is useful on desktop too. The real power is in the preconfigured Playground environments through blueprints (which you can easily create with the Step Library).

Say your plugin integrates with WooCommerce. You can create a blueprint that installs WooCommerce, sets up a test product, and installs your plugin from the current branch. Now every Playground link the AI generates loads an environment where you can actually test the integration—not just whether your plugin activates without errors.

Or you want to test across different configurations: multisite vs single site, classic editor vs block editor, different PHP versions. Create a blueprint for each scenario, generate AI instructions for each, and you have a test matrix that’s one click away.

GitHub Actions

You can take this further with a GitHub Action that posts a Playground link “Try it in Playground” as a comment on every PR. That way anyone reviewing the PR can test the changes without setting up a local environment.

The Step Library is available as an npm package, so you can integrate it into your own tooling and CI pipelines.

Let AI Create Blueprints for You

Something often overlooked: the Step Library is also useful for getting AI to help you create blueprints in the first place. The native Playground steps are low-level—things like writeFile and runPHP—so AI assistants often don’t grasp what’s actually possible with blueprints. The Step Library’s high-level steps are more intuitive, and with a JSON schema that describes them, AI can easily understand what’s available and generate useful blueprints.

Other New Step Library Features

Some notable other things I added recently:

wp-env.json import: Drop your .wp-env.json into the Step Library and it converts your local dev environment config into a Playground blueprint.

GitLab, Bitbucket, and Codeberg support: Not everyone uses GitHub. The Step Library now recognizes repository URLs from these platforms.

Paste detection: Paste a plugin URL, some PHP code, or even an existing Playground URL, and the Step Library figures out what it is and creates the right steps.

Try It

The Playground Step Library is where you can create your blueprint and generate AI instructions.

I’ve found myself using this on the train, in waiting rooms, wherever I have a few minutes and an idea I want to try. It’s not how I imagined WordPress development would work, but it does.

But here, I want to talk about something different: It happens that you search for a tool and then you come across something that almost does what you want, but not quite.

Before AI programming tools, you either had to be lucky to know the software stack, or it must be a really important problem to you that you would try to understand the codebase and make the modification you need.

Today, I can just use Claude Code to modify any tool how I like. So instead of turning away in frustration, I just ask Claude to help me fix what doesn’t work for me. How great is that?

A recent example for me has been transferring files to my Android Phone. OpenMTP exists but to me it has proven to be highly unrealiable, you need to remember to not have Preview open in macOS for it to work, and recently it didn’t complete a copy process but didn’t tell me about it. I only found out on the go that some files had not been copied.

So I realized, that I can use adb to push files to my phone using the debug mode. It’s very niche, I know, but it works. And then I realized a little UI would be nice, and I discovered darkhz’s adbtuifm. A tool written in Go but only tested on Linux, a file manager like Total Commander for the CLI that uses adb in the background.

And indeed, it didn’t really work well on macOS CLI. The left side appeared empty.

But this is what it looks like today:

So I forked it and adapted it to my needs:

• It now uses the current directory instead of the non-existent-on-macOS /home.
• Fixed the colors so that things are also readable in light mode.
• Introduced an ADB log pane to see what’s going on behind the scenes.
• It now shows size and last modification dates.
• Introduced history navigation.
• Even fixed a (tricky?) UI hang when deleting files.

The most important change for me probably was the first one, and, ok, I could have probably just changed the hardcoded string myself.

But it was such a joy to continue and make the tool nicer to use! Also, I don’t think I could have fixed that hanging UI before wasting too much time.

You can try my version, and maybe fork it and add more things you like yourself? I could send back a PR but maybe I won’t do it this time because my changes are opinionated and the repo seems abandoned with the last change in 2022.

Especially when trying to get larger amounts of PHP code to comply with the coding standards, it feels like this tool just scolds you and all you can do is to diligently work away on each and every violation that it discovers.

And you might have gotten yourself into such a situation because you realized well into the project that you forgot an important ruleset, or when you’re merging codebases.

Sniffs are Opinions

One important thing that we tend to forget: often we are in a position where we can actually make the decisions which rules to follow and which not. A ruleset prepared by someone else might contain things we disagree with. Thus phpcs contains the ability to exclude sniffs via its phpcs.xml configuration file, and I think it’s ok to make use of that. But also, I think that phpcs could be more helpful to you in doing so.

When you encounter such an overly eager ruleset, you might complain that the ruleset itself should be updated. But maybe you are not in a position to fight that battle, so you can just find a solution for yourself.

phpcbf can help fix things

The PHP Code Sniffer project comes with two main executables: phpcs, and phpcbf. While phpcs complains, phpcbf tries to help you. Sniffs can provide auto-fixers for violations they encounter and phpcbf applies them for you. But oftentimes it seems like there should be an auto-fixer but in the end, you have to fix it yourself.

A side-note here: maintaining the phpcs project is certainly not a piece of cake since it’s a project heavily exposed to opinion. Many things have to be considered, and it looks like there has been agreement that an auto-fixer can only be added if there is a single and clear solution to the problem.

Thus, there are a number of sniffs where the resolution of a violation needs a user decision. This decision could be complex, like you need to rearrange code, or add something that you forgot (like a type for a parameter). But I believe there are also decisions to make where it’s a matter of choosing between several options.

User Decision Required

One example of this is Squiz.Commenting.InlineComment.InvalidEndChar: “Inline comments must end in full-stops, exclamation marks, or question marks.” Let’s not argue about its validity but about the reason it cannot be auto-fixed: There are multiple valid end chars and an auto-fixer cannot know which one is the right one here.

So, what happens if we make phpcbf interactive, so that it can ask the user to select one of the potential fixes, and then just goes ahead and makes them?

Or, if you realize that you disagree with this sniff: what if phpcbf will just quickly add an <exclude ref="Sniff.Name"/> to your phpcs.xml? Or it could help you just disable the rule for the file? Or just ignore this line?

Many IDEs actually already have some of these ways of dealing with violations, either natively or through an extension. Bringing them to phpcbf itself would make this available to a wider audience and solutions could be baked in to sniffs.

Interactive Mode

All of these thoughts culminate in this idea to make phpcbf interactive. I didn’t know until recently that phpcs has an interactive mode, too. But all it does is to process a file and pauses to allow the user to edit the file, and then to process it again. It assists you in checking, but not in fixing.

So, here is how this could work. Let’s assume this test.php:

<?php

//helo
class test
{
echo 'hello';
}

This file has some problems as phpcs tells you (the selection of Sniffs here is a bit arbitrary but to show the variety of options we’ll face):

As you can see, some violations can be fixed, most cannot. The reason for those is that there is no auto-fixer implemented for them, and often the reason is that there is no one-and-only-way to fix this.

So let’s see how interactive mode would work here. In this first case I’d like to show a situation where there is no auto-fixer available. These would be the options:

Now let’s look at a case where an auto-fixer is available. In non-interactive mode, phpcbf would just fix it, but here you have the option to skip it, too. It would be nice if it even could preview the auto-fix:

Now let’s look come back to our example from above where it seems like an auto-fixer could exist but it does not because there are multiple ways to fix it. For this one, we’d have an interactive fixer that gives the user the choice how to fix it:

One could argue that you can do all of this today but I think with such an interactive mode we can relieve much of the pain it causes to get a code base to comply by streamlining what you need to do already today anyway: go through each violation and try to fix it.

Some of the choices I haven’t described yet:

• i would just append a // phpcs:ignore Sniff.Name to the line.
• d would add a // phpcs:disable Sniff.Name at the beginning of the file.
• p would add an <exclude ref="Sniff.Name"/> to your phpcs.xml.
• e would open an editor at the line of the code

In summary, this is a proposal to improve the user experience. I think this could transform an experience where phpcs is the tool that scolds you, to the tool that assists you in unifying a codebase to certain standards.

You can find the issue I created about this in the PHP CodeSniffer repo, and my implementation on Github. This is not yet a PR because they prefer to have a discussion it first but I worked on an implementation already so that you can experience how it feels to use it and don’t just have to imagine it. Find the instructions to do so on the bottom of the issue.

PS: to make the terminal output look well in this post, I have made this syntaxhighlighter-ansi plugin for the SyntaxHighlighter Evolved plugin for WordPress that will interpret the ANSI escape sequences from the terminal and convert it to colorful output like you can see above.

Behind the scenes this actually dominoed into migrating it to TypeScript and restructuring the code so that it now both powers the Web UI and the npm package.

Having those custom steps available now makes even more sense that the Playground CLI is production ready and you can use it for things like testing your WordPress plugin with Playwright, see this presentation Building Automated Tests with WordPress Playground from WordCamp Europe 2025 by my colleague Berislav “Bero” Grigicak.

In this example you can see a blueprint JSON that contains steps setSiteName and addPage that don’t exist in the library of steps of Playground. At the time of writing there are 36 custom steps with the goal of making it easier to do things that can be done with a blueprint already but need some complexity. See in the example below how creating a page can be done with runPHP and wp_insert_post but it’s visually easier with a step addPage.

import PlaygroundStepLibrary from 'playground-step-library';
const compiler = new PlaygroundStepLibrary();

const blueprint = {
    steps: [
        {
            step: 'setSiteName',
            sitename: 'My Site',
            tagline: 'A WordPress Playground demo'
        },
        {
            step: 'addPage',
            title: 'Welcome',
            content: '<p>Welcome to my site!</p>'
        }
    ]
};

const compiledBlueprint = compiler.compile(blueprint);
console.log(compiledBlueprint);

Which turns this into a valid blueprint:

{
  "steps": [
    {
      "step": "setSiteOptions",
      "options": {
        "blogname": "My Site",
        "blogdescription": "A WordPress Playground demo"
      }
    },
    {
      "step": "runPHP",
      "code": "\n<?php require_once '/wordpress/wp-load.php';\n$page_args = array(\n\t'post_type'    => 'page',\n\t'post_status'  => 'publish',\n\t'post_title'   => 'Welcome',\n\t'post_content' => '<p>Welcome to my site!</p>',\n);\n$page_id = wp_insert_post( $page_args );"
    }
  ]
}

You can then pass this blueprint to playground CLI to run it (see other demos by my colleague Fellyph):

import { runCLI, RunCLIServer } from '@wp-playground/cli';
await runCLI({
  command: 'server',
  login: true,
  blueprint: compiledBlueprint
});

You can also conveniently try it out in WordPress Playground with this link (and also view in the Step Library UI).

Finally, in the repo there are a number of examples that you can browse and I created a little screen recording of a few of them:

Happy coding!

I attended (German-spoken) FediCamp Graz 2025 last Saturday (see Heinz Wittenbrink’s summary in German) where we discussed a plethora of topics around the Fediverse, barcamp-style.

One question that we discussed and that has been bugging me for a long time, is why people are quite unwilling to switch to federated, open networks.

One reason is certainly is inertia. I guess it’s a human property to stick with what you know. Also change means work.

Another reason is ignorance. You know, like “bliss.” It can be comforting to focus on the good sides of your social consumption and not deal too much with the negative sides.

Following a train of thought, I realized that maybe many people don’t realize that they can’t be followed by people who are not on their network. And don’t realize that this is a lock-in by the platform that is not necessary.

To combat this, I created a little one-page website (source on Github, open to PRs!) that is meant as something that you can take and send this URL to a person you’d like to follow who is on a closed social network.

It contains a table of ActivityPub equivalents of social networks (see also my WordCamp Europe 2025 presentation What you’re missing if you don’t have your own WordPress; slides, video):

At the bottom of the page you can customize it:

Probably this is not going to change the needle significantly, but I see this as a little contribution to enable raising awareness about the problem. The decentralized fediverse surely has a steeper learning curve because you need to make a choice before you start. But I think it’s worth it.