The Platform

The Platform is a multiplayer, user-generated-content platform built in Unity where creators can build, customize, and share their own interactive experiences.

Creators can place objects into a world, customize them, add behaviors and gameplay logic, and turn their creations into reusable building blocks. The goal is to give users the freedom to create experiences without requiring them to build everything from scratch, while allowing those creations to be shared and experienced together with other players.

The platform supports multiplayer experiences on PC and VR, with content that can be dynamically created, customized, saved, published, and loaded.

I worked across several of the platform's core systems, with my main contributions focused on runtime customization, persistence, and multiplayer character systems.

I designed and implemented the object override and serialization architecture, allowing players to modify spawned assets at runtime while keeping those changes synchronized between players and persistent across save/load cycles. I also implemented a large part of the experience save/load system, which reconstructs an entire experience — including object identity, hierarchy, configuration, and customizations — so creators can return to their work without losing its state.

Another major contribution was integrating Opsive's Ultimate Character Controller (UCC) with FishNet multiplayer. Because the two systems were not designed to work together directly, I had to bridge their initialization, ownership, and runtime behavior. I also extended UCC functionality to support dynamic runtime configuration, allowing characters to work with the platform's AssetBundle-based architecture rather than relying entirely on pre-configured prefabs.

One of the biggest challenges was making runtime customization work consistently across the entire lifecycle of an object:

Edit → Synchronize → Save → Reload → Reconstruct

I built the override system around network-synchronized object state and persistent serialization, allowing modifications to be associated with individual objects and reapplied when they are reconstructed. This was particularly challenging for complex asset hierarchies where overrides could target nested GameObjects and components.

The UCC/FishNet integration presented a different challenge: two complex systems with different assumptions about character initialization and ownership had to operate as one networked character architecture. I adapted UCC's runtime behavior so characters could be configured dynamically as they were spawned, which was essential for an AssetBundle-driven platform.

These systems helped establish the foundation for a platform where content is not static. Objects can be dynamically spawned, customized, synchronized, saved, published, and reconstructed while preserving their state across multiplayer sessions.

The result was a more flexible architecture capable of supporting user-generated experiences without requiring every possible object configuration or player setup to exist as a pre-built Unity prefab.