Picture an instructional designer on a Tuesday morning. She has an idea for a new kind of learning activity, a collaborative chess board where two students play through a tactical puzzle together, each move logged for the instructor to review later. The pedagogy is clear. The interaction design is clear. The hard part is everything else.

If she builds it as a SCORM package, the activity can show up in the course, but it cannot remember who moved when, and it certainly cannot let two students share a board in real time. If she builds it as an H5P content type, the same wall appears. If she goes the LTI route, she needs to spin up a separately hosted web service, deal with authentication, deploy it, monitor it, and maintain it indefinitely for a single course activity. If she builds it as an XBlock for Open edX, she gets the power she needs but loses the ability to share the activity with colleagues on Canvas or Moodle.

So the activity does not get built. The roadmap quietly contracts to fit the tools, and a year later the course looks much like it did before.

This pattern is so familiar in learning technology that most teams have stopped noticing it. The standards that govern online learning activities were each excellent answers to questions the field was asking ten or twenty years ago. They are now the reason today’s answers remain out of reach. There is a missing layer in modern LMS design: a way to create activities that are genuinely interactive, genuinely portable, and genuinely safe to share, without standing up infrastructure for each one.

A new open standard called PXC, Portable, sandboXed Components, pronounced “pixie”  is built to be that layer.

Why the old standards keep running out of room

To understand what PXC changes, it helps to be specific about what its predecessors leave out.

SCORM, the granddaddy of the family, was designed in an era when “interactive content” meant a self-contained Flash file that reported a final score back to the platform. It is portable across LMSs, which is its great virtue. But it has no concept of a server. Two learners cannot share a SCORM activity. State does not persist in any rich sense. Grading happens at the end, on the client, on trust.

H5P modernized the authoring experience and gave designers a friendlier toolkit, but it inherited SCORM’s architectural limitation: the activity runs entirely in the learner’s browser. The server is not part of the picture.

LTI took the opposite approach. Instead of packaging the activity, it packages a link, a way for the LMS to hand the learner off to a separately hosted tool. This works, and most LMSs support it, but the cost is hidden in plain sight: every LTI activity is a service that someone has to host, secure, scale, monitor, and keep alive for as long as the course runs. For a major vendor with engineering teams, this is fine. For a single instructional designer with a good idea, it is the end of the conversation.

XBlock, the activity framework inside Open edX, gives authors real backend power. Activities can persist state, grade server-side, and integrate deeply with the platform. The catch is in the name of the platform. An XBlock runs on Open edX. It does not travel.

Each of these standards solves part of the problem and forfeits another part. None of them was designed for a world in which a course author might describe an activity to an AI assistant in the morning and have students using it that afternoon.

None of these standards was designed for a world in which a course author might describe an activity to an AI assistant in the morning and have students using it that afternoon. None of them was built for activities that are interactive, persistent, multi-user, portable across platforms, and safe enough that an LMS can accept them from ordinary uploaders.

That last requirement is the one nobody could solve. And it is the one PXC starts from.

The idea behind PXC

The core insight of PXC is that an interactive learning activity is really two programs glued together: a client program the learner sees and interacts with, and a server program that holds state, grades, persists data, and coordinates between users. Every previous standard either gave you both but locked you to one platform, or made you host the server yourself, or simply pretended the server did not need to exist.

PXC packages both programs into a single, portable file that an LMS can accept and run. The client side is web code that paints the learner’s screen. The server side is code compiled to WebAssembly, the same sandboxing technology that lets browsers safely run untrusted code from the open internet and executed inside a tightly controlled sandbox on the platform.

This last detail is the unlock. The reason no previous standard let you upload backend code is that running untrusted server code is, in the general case, a serious security problem. WebAssembly changes the equation. Code compiled to a WebAssembly component can only talk to the outside world through a precisely defined interface. It cannot read arbitrary files, cannot make arbitrary network calls, and cannot reach into the host platform’s memory. The sandbox decides what the activity is allowed to do, and the activity has no recourse to do anything else.

The practical consequence is that an LMS can finally do something it has never been able to do before: accept arbitrary activity packages from ordinary users without inviting catastrophe. Powerful capabilities; network access, external service integration, file storage are not granted by default. A platform administrator approves them on a per-activity basis, the way a smartphone owner approves which apps can access the camera.

Without a credible sandbox, a portable, server-capable, user-uploadable activity standard is a daydream. With one, it becomes architecture.

The anatomy of a PXC activity

A PXC activity is a folder. The simplicity is part of the point.

The smallest possible activity needs only the manifest and the UI. Activities that require persistence, grading, or multi-user state add the sandbox layer. Building an activity is a single command:

make -C samples/my-activity build

At runtime, the activity is mounted onto the page as a standard web component, <pxc-activity>. The host page does not need a framework-specific integration. The browser’s own component model is the integration. Any LMS that can serve HTML can host the activity.

That is the entire conceptual surface. A folder, a manifest, a UI, an optional sandbox, a web component. Everything else — the runtime that loads it, the sandbox that runs it, the storage that backs it, the LMS that embeds it — is the platform’s problem, not the author’s.

This is also the design decision that makes PXC tractable for AI-assisted authoring. The surface is small enough for a generative AI assistant to author against reliably, and the same property makes it small enough for a human to learn in an afternoon.

What you can actually build with it

The most convincing argument for any new standard is what people have already built with it. The PXC project ships with eighteen reference activities, and the range tells the real story.

At the simple end sits helloworld, a folder, a manifest, a UI, no sandbox. It exists to prove the standard works. A few steps up, mcq is the activity worth studying as a starting point for real work: a multiple-choice question with configurable answers and a sandboxed grader. Once an author understands mcq, the same shape carries forward to everything more complex.

Then the standard starts doing things its predecessors never could. chess is a turn-based game with full player management and persistent game records — the activity our instructional designer from the opening paragraph could now build in an afternoon. collab-editor is a shared text editor built on Yjs, with multiple learners typing into the same document and markdown rendering on the side. flappy-bird ships with both personal best scores and a course-wide leaderboard, because once you have persistent server state, a leaderboard is a few lines of code rather than a separately hosted service.

The activity that may be the most strategically important, though, is scorm, a PXC activity that plays SCORM content. The new standard does not require institutions to abandon their existing libraries. PXC can host the previous generation while the next one is built.

The full set of eighteen samples covers a deliberately wide range of use cases:

What unites these activities is not their domain. It is that they all use the same packaging, the same runtime, the same security model, the same web component. A course author who learns the shape of helloworld is most of the way to understanding chess. The standard does not branch into special cases for each kind of activity. The same primitives carry all the way through.

Why portability is the word in the name

The “P” in PXC is portable, and the project takes that seriously enough to ship its own bridge to the rest of the world.

The deeper claim is that a PXC activity is a single package that can run on any conformant LMS. That eliminates the XBlock problem, the activity is not chained to one platform. But conformant LMSs do not exist yet, because the standard is new. So the project ships an LTI 1.3 tool provider as part of the same codebase.

LTI 1.3 is the integration mechanism that nearly every modern LMS already speaks fluently Open edX, Canvas, Moodle, Brightspace, Blackboard. By offering PXC activities through an LTI 1.3 tool provider, the project gives institutions a way to use PXC activities today, on the LMSs they already run, without waiting for native PXC support to land. Native integrations become an enhancement, not a prerequisite. The bridge handles platform registration and deep linking, which are the two LTI features that matter for embedding activities at the course level.

Portability also extends, with some care, to offline use. PXC supports two approaches:

Either approach is valid; the choice belongs to the activity author and the institution. The point is that offline is a first-class consideration in the standard, not an afterthought.

What this means for the people who actually build courses

The shift PXC introduces lands differently depending on where you sit.

The people building it

PXC is being developed by Team Edly, the creator of Tutor, the deployment tool that has become the de facto standard for running Open edX in production.

PXC made its public debut at the Open edX Conference 2026 in Salt Lake City, where Régis Behmo, VP of Engineering at Edly, showcased how the platform is redefining the creation and management of interactive learning content. For organizations exploring the future of engaging digital learning experiences whether on Open edX or any other LMS; PXC represents an important step forward in making rich, interactive content more accessible and scalable. The missing layer, found

Learning activities are the unit of value in an LMS. Enrollment, grading, analytics, credentialing every other capability the platform offers exists to support and measure them. For two decades, the standards governing those activities have made institutions choose: portability or power, interactivity or simplicity, ambition or maintainability. The choice has shaped what online learning could become, and it has shaped it downward.

PXC is the first serious attempt to remove the choice. Activities can be interactive and portable. They can have a server and require no separate hosting. They can be uploaded by anyone and run safely. They can be authored by humans and generated by AI. They can run on Open edX, Canvas, Moodle, and whatever comes next.

The instructional designer with the chess puzzle idea no longer has to abandon it. That is what a missing layer looks like once it is in place.

Ready to Build Learning Experiences That Go Beyond Today’s LMS Limitations?

Whether you’re an instructional designer looking to create richer learning activities, a platform team exploring scalable content innovation, or an institution evaluating the future of LMS interoperability, PXC opens up possibilities that traditional standards simply cannot support.

Get in touch with the Edly team to learn how PXC can help you build interactive, portable, and future-ready learning experiences across Open edX and beyond.

View the PXC project on GitHub and explore the architecture, sample activities, and implementation details.
 Book a conversation with our experts and explore what’s possible with PXC.

Frequently Asked Questions (FAQs)

What is the new LMS content standard?

PXC (Portable, sandboXed Components) is an emerging LMS content standard designed for the next generation of digital learning experiences. Unlike traditional standards such as SCORM, H5P, and LTI, PXC allows learning activities to include both the user interface and secure backend functionality in a single portable package. This enables advanced capabilities such as real-time collaboration, persistent learner data, server-side grading, multiplayer interactions, and AI-generated learning activities while maintaining portability across LMS platforms. As learning experiences become more interactive and personalized, PXC offers a modern foundation for building and sharing rich educational content.

What is the missing layer in modern LMS design?

The missing layer in modern LMS design is the ability to create learning activities that are simultaneously interactive, persistent, portable, multi-user, and secure without requiring custom infrastructure or platform-specific development. Existing standards such as SCORM, H5P, LTI, and XBlocks each solve part of this challenge but force trade-offs between portability and functionality. PXC (Portable, sandboXed Components) aims to fill this gap by enabling rich learning experiences with built-in backend capabilities that can run safely across different LMS platforms.

What is PXC in eLearning?

PXC (Portable, sandboXed Components) is an open standard for creating interactive learning activities that combine both frontend and backend functionality into a single portable package. Unlike SCORM, H5P, or traditional LMS plugins, PXC supports persistence, real-time collaboration, grading, and multi-user experiences while remaining portable across learning platforms.

How is PXC different from SCORM?

SCORM enables content portability across LMSs but does not support server-side logic, persistent state, or real-time multi-user interactions. PXC adds these capabilities by allowing activities to include secure backend functionality through WebAssembly-based sandboxing.

How does PXC compare to H5P?

H5P is excellent for creating interactive content but runs entirely in the learner’s browser. PXC extends beyond browser-based interactions by supporting server-side processing, persistent data storage, collaboration features, and advanced assessment capabilities.

Is PXC an alternative to LTI?

PXC addresses many of the challenges associated with LTI. While LTI typically requires authors or institutions to host and maintain separate services, PXC packages the learning activity and its backend logic together, reducing infrastructure complexity while maintaining portability.

Can PXC work with Open edX, Moodle, Canvas, and other LMSs?

Yes. PXC is designed as a portable standard that can run across different LMS platforms. It also includes an LTI 1.3 bridge, enabling institutions to use PXC activities on platforms such as Open edX, Moodle, Canvas, Brightspace, and Blackboard today.

What types of learning activities can be built with PXC?

PXC supports a wide range of activities, including quizzes, coding exercises, flashcards, collaborative editors, multiplayer games, leaderboards, interactive videos, chat applications, and real-time learning experiences that require persistent state and user collaboration.

Is PXC secure for LMS administrators?

Yes. PXC uses WebAssembly-based sandboxing, which allows LMS platforms to safely run uploaded activity packages without granting unrestricted access to servers, files, or networks. Administrators can control permissions on a per-activity basis.

Can AI generate PXC activities?

PXC was intentionally designed with a simple architecture that makes AI-assisted authoring practical. Its small development surface allows both human developers and AI tools to create interactive learning activities more efficiently.

Why does PXC matter for the future of online learning?

PXC removes the traditional tradeoff between portability and functionality. It enables learning experiences that are interactive, persistent, collaborative, portable, and secure, helping institutions create more engaging digital learning environments without increasing infrastructure complexity.

Is PXC open source?

PXC is being developed by Edly, the team behind Tutor, the widely adopted deployment platform for Open edX. The initiative is designed to advance open and interoperable learning technology ecosystems.