WordPress real-time collaboration is not a shipped WordPress Core feature as of October 10, 2026. The project is exploring a “server-aware” design in which WordPress Core would participate in synchronization and retain more control over collaborative state. That work is early, no engine has been selected, and the proposal is not ready for inclusion in Core.
The distinction matters because an earlier Gutenberg experiment synchronized a shared document between browsers and kept unsaved changes in browser memory. The newer direction asks the server to merge or record edits, improve attribution and control, and address the performance and reliability problems that kept real-time collaboration out of WordPress 7.0.
As an Amazon Associate I earn from qualifying purchases.
What “server-aware editing” means
In a server-aware collaboration model, the WordPress server is an active participant rather than merely the place where a finished post is saved. It can hold collaborative state, accept updates, merge concurrent changes, enforce permissions, and provide a history that clients can synchronize against. The editor still runs in a browser, but the browser is no longer the only place where the live working document exists.
That is a proposed architectural direction, not a feature you can turn on in a standard WordPress installation. The September 18, 2026 Make WordPress Core proposal describes exploratory designs and says the work is not ready for Core inclusion. It is therefore more accurate to discuss how the project might work than to give installation instructions for a finished feature.
#1 Best Overall
Is real-time collaboration available in WordPress yet?
No. On May 8, 2026, WordPress Core announced that real-time collaboration would not ship in WordPress 7.0. The decision followed concerns about robustness, race conditions, server load, memory efficiency, and recurring bugs discovered through fuzz testing. The announcement did not cancel the goal permanently; it left room for broader testing and another design iteration.
The WordPress.org version history records WordPress 6.6.10 on October 6, 2026, but that release entry does not indicate that server-aware collaboration shipped. A current WordPress site should not be described as having native simultaneous co-editing simply because it runs a recent version.
| Date | Project status | What it means |
|---|---|---|
| March 10, 2026 | Developer documentation describes the earlier Gutenberg experiment | The experiment used a browser-side Yjs document, a provider-based synchronization layer, HTTP polling by default, and a sync.providers filter for alternative transports. |
| May 8, 2026 | Real-time collaboration removed from the WordPress 7.0 release plan | Core cited robustness, race conditions, resource usage, and fuzz-testing bugs; the broader project continued. |
| September 18, 2026 | Server-aware collaboration proposal published | Core began exploring server-controlled collaborative state and several candidate synchronization engines. |
| October 10, 2026 | Exploration remains early | No selected engine, production package, minimum server specification, benchmark, or release date is established. |
How the earlier browser-centered experiment worked
The earlier experiment used Yjs, a conflict-resistant replicated data type (CRDT), to represent the post in each participating browser. Each client held a copy of the document, exchanged updates with other clients through a provider, and merged those updates locally. A person could type, move blocks, or make other edits while the editor behaved much like a normal Gutenberg session.
Recommended Free Tools
The important limitation was where unsaved state lived. The working document and its pending changes remained in browser memory until someone saved. In the words of Chris Zarate, a WordPress Core contributor, in the September 18 proposal: “The current RTC experiment in Gutenberg merges edits only in the browser.” That arrangement can make a group appear to edit together, but it leaves the server without a complete, authoritative view of who changed which part of a document during the session.
Transport in the earlier experiment
The March 10 developer note says the default provider used HTTP polling. A plugin could use the sync.providers filter to replace or extend that transport, including a WebSocket-based provider. Those details describe the earlier experiment only. They should not be treated as the transport contract for the proposed server-aware architecture.
Why classic meta boxes were a problem
The experiment did not synchronize classic WordPress meta boxes. To avoid losing data, collaboration was disabled when a post contained meta boxes. The developer guidance suggested moving data to registered post meta with show_in_rest enabled, or using a sidebar plugin or a block-based interface instead.
This is a compatibility lesson from the earlier implementation, not a confirmed permanent rule for a future server-aware feature. A developer evaluating collaborative editing should nevertheless audit every field that sits outside the block editor’s synchronized document.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Why WordPress is considering a server-side design
A browser-only CRDT can merge edits quickly, but it shifts important responsibilities to clients. Every browser needs compatible state, the group needs a reliable exchange path, and the server learns about changes only when a save or other request reaches it. That creates questions about attribution, permissions, recovery after a disconnected client, and what happens when the server’s saved revision differs from the document being edited.
The May release decision added operational concerns. Core reported race conditions, memory-efficiency issues, server-load questions, and recurring bugs found with fuzz testing. A server-aware design does not automatically solve those problems; it makes them explicit engineering responsibilities. The server must process collaboration traffic without making ordinary editing unreliable, and the project must measure the cost rather than assume that a particular engine will be inexpensive.
The three synchronization engines under consideration
The September proposal names three candidates. They are design options in an exploratory repository, not competing products and not a ranking. The sources provide mechanisms but no validated speed, reliability, or hosting benchmarks.
| Candidate | Where collaborative state lives | When synchronization occurs | How concurrent edits are handled | Server work implied |
|---|---|---|---|---|
| Yjs-server | A Yjs CRDT document on the server, shared with clients | As clients exchange updates with the server | Yjs merges CRDT updates | Maintain the document, accept and distribute updates, and manage server-side persistence and access control |
| Distributed Editing (DE-RTC) | The saved version plus each editor’s proposed version and its starting base | On save or autosave rather than every individual change | A three-way merge compares the latest saved version, the proposed version, and the base version from which editing began | Detect divergence, perform the merge, report conflicts, and write the resulting revision |
| Intent log | An ordered server log of semantic editing operations | When clients send operations such as block moves | An operational-transform engine orders and transforms intents so clients can replay them | Store, order, transform, authorize, and replay the operation log |
Yjs-server
In the Yjs-server option, the server hosts the CRDT document rather than leaving each browser to maintain the authoritative working copy. Clients send updates to that document and receive updates from it. The approach keeps the continuous-update behavior associated with CRDT collaboration while giving WordPress a place to apply permissions, persistence, monitoring, and recovery policies.
The proposal does not state how a server-hosted document would be stored, how long unsaved state would live, or what transport every host would support. Those implementation decisions remain part of the exploration.
Rank #3
Distributed Editing (DE-RTC)
DE-RTC takes a save-oriented approach. When an editor began, the system recorded a base version. If another person saved first, the next save could compare three documents: the latest saved version, the editor’s proposed version, and the original base. The merge then incorporates changes made on both sides where they do not conflict.
Because synchronization happens on save or autosave instead of every keystroke, this model could reduce continuous update traffic. It also means that conflict detection and resolution become especially important at save time. The proposal supplies no benchmark showing how it performs under a particular workload.
Intent log
An intent log records concise semantic operations, such as moving a block, rather than repeatedly sending a complete document state. An operational-transform engine orders those operations and transforms them when necessary so another client can replay the same sequence.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
This model could make the meaning of an edit clearer to the server and to a future history or audit interface. It also requires WordPress to define a complete, secure vocabulary of operations and to handle clients that are offline, outdated, or unable to interpret a newer intent.
Earlier browser-only editing versus the proposed server-aware direction
| Concern | Earlier experiment | Proposed server-aware direction |
|---|---|---|
| Primary collaborative state | Each browser held a CRDT copy in memory | WordPress Core would participate in holding or processing collaborative state |
| Server participation | Clients exchanged updates; the server was not the authoritative live merger | The server could merge documents, compare revisions, or maintain an ordered intent log |
| Unsaved edits | Stayed in browser memory until a save | The design question includes how the server should control, retain, and recover live state |
| Attribution and control | The project identified difficulty attributing individual edits during a session | Server involvement is intended to improve control, permissions, and knowledge of collaborative state |
| Update timing | Provider-based exchange, with HTTP polling as the default described in the developer note | Could use continuous server updates, save-time merging, or operation delivery, depending on the selected engine |
| Performance responsibility | Browser memory and client synchronization carried much of the work | Core must measure server load, memory use, transport cost, and behavior at different update frequencies |
This table describes the project’s architectural accounts. It is not an independent performance test, and it does not establish that one column is faster or safer in every hosting environment.
What a server-aware editing session could look like
The exact user interface is not defined, but the proposal lets you understand the responsibilities a finished implementation would need to cover.
Rank #4
- Open the post. WordPress authenticates the editor and establishes which document and revision the session may access.
- Join collaborative state. Depending on the engine, the client receives a server-held CRDT document, the latest saved version plus a base revision, or an ordered set of editing intents.
- Edit in Gutenberg. The browser renders the document and sends changes through the selected transport. A continuous engine may send updates while the user works; a save-oriented engine may defer comparison until autosave or save.
- Receive another editor’s change. The server merges a CRDT update, transforms an operation, or detects that a proposed save is based on an older revision.
- Resolve an incompatibility. Non-overlapping edits can be combined automatically. A genuine conflict requires a defined UI and policy; the sources do not specify what that interface will be.
- Save and persist. WordPress writes a revision or post update and must preserve the relationship between the saved content and any still-active collaborative state.
- Recover from interruption. A reconnecting browser needs a way to learn which updates it missed and whether its local state is still valid. The project has not published the final recovery protocol.
Performance, hosting, and security questions that remain open
Server awareness creates measurable costs. A host may need to keep collaborative documents in memory, process frequent updates, run merges, store operation history, or maintain long-lived connections. The proposal calls for testing the cost of the new approach and for better collaboration at lower update frequencies. It also considers alternative transports for hosts with additional resources.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteNo final minimum PHP or database version, CPU or memory requirement, supported hosting tier, transport requirement, benchmark, or release date has been published for the proposed design. WordPress’s general hosting documentation tells site owners to check current technical requirements, but those general requirements cannot be substituted for collaboration-specific specifications.
Security and attribution
A server that sees collaborative updates can enforce authorization closer to the source of truth and can associate an operation or merged revision with an authenticated participant. That does not guarantee a complete audit trail: the project still has to define identity, retention, permission checks, revision semantics, and behavior for plugins that alter post data. Treat server awareness as an opportunity for stronger control, not as proof that every edit will automatically be attributable.
Transport choices
The earlier experiment’s HTTP polling and optional provider filter show that transport can be replaceable. The later proposal explicitly keeps transport and performance under consideration, including alternatives for hosts with more resources. Do not assume that a future feature will require WebSockets, or that HTTP polling from the experiment will remain the default.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.WordPress Notes are not real-time co-editing
Notes are a separate editorial-feedback mechanism. WordPress documentation says Notes were introduced in WordPress 6.9, with more advanced features in 7.1. A user with permission to edit a post or page can attach a note to a block or selected text, reply in a thread, mention collaborators, and resolve feedback. Notes are visible in the editor to users who have permission and do not appear in published content.
That workflow lets people discuss a document without simultaneously changing its content. It should not be described as the name for WordPress’s real-time collaboration project.
Best Value
Where Notes can be used
Custom post types can support Notes when a theme or plugin author enables them. Notes are not available in Site Editor templates and template parts. Those availability rules concern commenting and review, not synchronized co-authoring.
What developers should plan for now
Keep collaborative data in supported editor surfaces
If a plugin’s critical fields live in classic meta boxes, the earlier experiment would disable collaboration to avoid data loss. Registering post meta with show_in_rest enabled, exposing controls in a sidebar, or representing the data with blocks can make the data visible to modern editor workflows. None of those steps activates server-aware collaboration today, but they reduce the amount of state hidden outside the editor document.
Separate editorial comments from content state
Use Notes or another review workflow for feedback threads, and keep the post’s actual data model explicit. A note attached to selected text is not a revision, a block operation, or an autosave. Plugins should not infer that a comment thread supplies the conflict-resolution guarantees of a collaboration engine.
Free tools Windows power users keep installed
One-click scans. No signup required.
Design for changing synchronization contracts
The three candidate engines have different assumptions about update frequency, document representation, and conflict handling. A plugin that listens to editor changes, stores temporary state, or adds custom transports should avoid depending on an unfinalized API. Watch the feature-plugin and exploratory-repository work for a published contract before treating any candidate as stable.
How site owners and editors should evaluate claims
- Check whether a product or plugin is describing simultaneous content editing or merely comments, approvals, or review notes.
- Ask which WordPress version and which feature plugin provide the behavior; do not infer availability from the presence of Notes or from a recent core release.
- Look for a documented synchronization engine, recovery behavior, permission model, and data-compatibility list.
- Confirm measured server requirements for the exact workload. A generic WordPress hosting recommendation does not establish that a host can support continuous collaborative updates.
- Test posts containing custom fields, embeds, reusable blocks, revisions, autosaves, and plugin-owned data before inviting a large editorial team.
- Keep ordinary backups and revision recovery in place. Collaboration does not remove the need to recover from a bad merge, a plugin conflict, or an interrupted save.
What happens next in the project
The proposal says the synchronization engines and transports are being developed in an exploratory repository. The stated eventual aim is to package a preferred engine in a feature plugin for broader use and testing. That sequence matters: a feature plugin would provide a place to exercise the design before any decision about WordPress Core inclusion.
Until that work produces a selected engine, measured costs, compatibility guidance, and a release plan, statements about guaranteed support are premature. The most useful way to follow progress is to distinguish a proposal, an experimental repository, a feature plugin, and a Core release; they are different maturity levels.
Practical answer for teams deciding today
If your team needs simultaneous editing now, do not assume that a normal WordPress Core installation supplies it. You can use Notes for contextual feedback, editorial assignments, and threaded review, but plan a separate process for merging actual content changes. Keep plugin data exposed through supported editor interfaces, test autosaves and revisions carefully, and treat any third-party collaboration layer as an independent system whose compatibility and server cost must be verified.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →For developers, the safest preparation is architectural rather than speculative: keep data registered and REST-visible where appropriate, avoid undocumented editor internals, make save and revision behavior explicit, and monitor the WordPress collaboration project for a feature-plugin API. For site owners, the key decision is not which of the three proposed engines is “best”—no winner has been named—but whether a future implementation publishes the operational guarantees your editorial workflow requires.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
