In Lost Skies, I developed the Atlas Lifters, a versatile anti-gravity tool that allows players to manipulate objects in the world—whether for building, exploration, or creative problem-solving. The system started as a simple prototype for attaching Lifters to objects, and grew into a fully-featured gameplay mechanic supporting both singleplayer and multiplayer scenarios.

Players equip and throw Atlas Lifters, which activate upon impact with valid physics objects. In early singleplayer builds, I refined the attachment system and balancing mechanics, ensuring intuitive placement and power scaling. Later, in multiplayer tests, I implemented network authority checks and synchronization to keep object states consistent between clients.

The Lifters can be attached to almost anything—logs, loot, animals, even other players. You can see an example of that in the attachment demo, where players creatively use Lifters to interact with the environment.

I also built in multiple ways to detach or destroy Lifters. Players can shoot them off objects, demonstrated in this video, or combine them with tools like cutting weapons, as shown in this clip.

Power management was a core design focus. Each Lifter has a limited charge and will fail once depleted. In this example, you can see what happens when the battery runs dry—Lifters lose their effect and can either drop off or explode for added feedback.

Balancing weight was another key challenge. I implemented a system where players need to calculate how many Lifters are required to make an object float. The mass calculation prototype shows this system in action, where adding or removing Lifters directly affects object behavior.

And finally, maintaining control in multiplayer meant developing a robust networked authority system, showcased in this video. This ensured smooth player interaction, even in complex scenarios with multiple Lifters and objects in play.

I developed a dynamic ladder system for Lost Skies, allowing players to place ladders on modular ship panels of varying sizes. Each ladder is procedurally generated to adapt to the panel it’s attached to, ensuring a seamless fit and consistent climbability.

The system started with an early prototype, where ladders were assembled from individual segments. This version was ultimately discarded in favor of a more streamlined approach using procedural mesh generation, which you can see in this clip.

During development, I added start and end point calculations to determine exactly where players can enter and exit ladders. In this video, you can see the first successful climb test using those calculations.

Ladders can snap to other ladders placed above or below them, creating continuous climbable paths. This video shows the snapping system in action, finalizing the modular ladder placement mechanic.

Because ladders can be moved around on the ships, I implemented automatic recalculation of climb points and snapping behavior whenever a ladder’s position changes. You can see this demonstrated in this clip.

Ladders integrate tightly with the ship building system, adapting to the different panels they’re placed on. Here’s a look at how they work with panels, ensuring proper alignment and functionality.

I also tested the ladder system directly on ships in motion, as seen in this early ship test, to make sure climbing works reliably in dynamic environments.

Climbing was refined over multiple iterations. This video shows one of the key climb tests, while this early clip highlights initial experiments with player movement before climbing logic was fully integrated.

As a final layer of polish, I enabled players to build and place ladders even while climbing them. You can see this unique feature demonstrated in this clip, adding more freedom and creativity to ship construction.

One of the biggest challenges I worked on in Lost Skies was the Herald—a giant flying creature that attacks your ship in the skies. It was designed as a dynamic boss battle that feels like a naval fight, but in the air. The Herald isn’t just a one-off enemy; it was built with modular systems in mind, so we could easily create multiple variants with different looks, attack patterns, strengths, and weaknesses.

The early prototypes were rough but helped shape the system. One of the first flight tests ended with the Herald crashing straight into the ground, which you can see in this fun (and slightly painful) fail video. Before we even had a full creature model, I built a basic logic test with cubes flying around the player’s ship, demonstrating the future movement and circling behavior. You can check that out in this early AI prototype.

Once we nailed down the behavior, I added procedural motion to bring the Herald to life, shown in this skinned and animated version. The attack systems came next. The Herald uses turrets to attack player ships, giving it a sense of power and making the encounter feel like an intense naval battle. You can see the first attack test in this turret attack demo. I also experimented with different attack mechanics like the orb attack, which you can see in this editor test with gizmos.

Beyond combat, the Herald needed to roam the world and react to player actions. I implemented roaming behavior where the Herald travels between islands, detects ships, and chooses whether to engage. There’s a sped-up editor preview showing this in action here: roaming and pathfinding demo. Once everything came together, we had a full loop: roaming, detecting a ship, launching attacks, and returning to its path afterward. You can see the entire flow in this full gameplay loop.

Finally, I integrated the Herald into the game world. One of the first real in-game tests shows the Herald in all its glory, highlighting its massive scale and movement. You can check that out in this ingame test. Since the Herald was modular, we could easily swap out parts in the config to create entirely new versions in minutes. Here’s an example showing one of those variations: modular Herald variant.

The Herald ended up playing a major role in the trailer for Lost Skies. You can see it featured front and center in this trailer showcase.

The Orb Attack is one of the Herald’s signature abilities. I designed it to be highly customizable, with a focus on making it easy to set up new patterns in the editor. I built a tool inside Unity that works like a pixel art editor, where you can simply draw the shape of the attack pattern. You can see the tool in action in the orb pattern editor.

Using this system, I created different projectile formations, like a wide barrage pattern in the first gameplay test, and a more focused spread in the second pattern example. Once they were working in the editor, I brought them into gameplay, where the Herald fires a cross-shaped attack and hits the ship in the cross attack demonstration. In another sequence, the player’s turrets manage to shoot down some of the orbs, but the barrage is too overwhelming, shown in the orb defense gameplay.

The targeting system was just as important. The Herald positions itself to the side of the player’s ship before launching an attack, emphasizing the naval combat feel. Target detection is visualized in the targeting system editor preview, and you can adjust things like line of sight and other parameters directly in the targeting editor interface.

In the final version, different orb patterns can be combined dynamically in combat, as shown in the orb attack gameplay showcase. Players can try to dodge or defend against them, like in the dodged attack sequence, or take a direct hit, shown in the impact demonstration.

The sails are modular building parts for your ship. They’re what push it forward, but only if they’re aligned properly to the wind. I wanted the interaction to feel satisfying and responsive, with clear feedback. When the sail isn’t catching the wind, it flutters loosely. But once it’s aligned perfectly, it stretches tight and you instantly feel the power kicking in.

The first test focused on the basic interaction—opening and closing the sails manually with the player character. You can see how smooth that is in the initial sail test. From there, I worked on visualizing how the sails contribute to movement in different situations. In the sail control and interaction demo, I show the sails opening and closing inside the editor, with gizmos displaying how much wind contribution they’re getting at any given time.

The first dynamic behavior test focuses on wind alignment. Even with both sails open, they lose effectiveness if they aren’t aligned with the wind direction. I added variation between small and large sails—the bigger sails are more forgiving and can catch wind even when they’re not perfectly positioned.

In the wind response demo, I show how the sail reacts when it hits the perfect wind angle. There’s a little pop in the animation, giving instant feedback that you’re in the sweet spot. Finally, the advanced sail setup demonstrates more fine-tuning—opening, closing, and adjusting the sails to maximize wind contribution.

The wind system was a key feature for Lost Skies. In a world built around floating islands and flying ships, wind defines the entire gameplay loop—especially when it comes to traversal and ship handling. It also tied directly into the sail work I did earlier, making it one of the most important systems in the project.

I started by building a flexible and intuitive editor for setting up wind behavior across the world. Strength, direction, variation over time—all easy to tweak and visualize. You can see the core of that system in the wind system prototype.

We implemented island-based wind zones, so the wind changes direction and strength depending on which island you’re flying near. That’s shown in the wind zone demo. To avoid any harsh transitions, I added interpolation between zones, which keeps the experience smooth as you travel. You can see that in action in the wind interpolation test.

The wind could also shift dynamically over time, changing direction and strength in real-time to add unpredictability to navigation and combat. There’s a speed-up version showing that behavior in the dynamic wind variation demo.

Once the core system was solid, the FX team hooked into it to add wind lines and other visual cues. The wind FX integration shows how they used the system to bring the world to life. For debugging and polish, we also used flowmaps to visualize wind direction and behavior in real time, shown in the wind flowmap implementation.