As always, I started with a prototype. But before even touching code, there’s a ton of research behind the scenes. I played games like Skate, THPS, and even more obscure ones like Skatebird, just to get a feel for different approaches and figure out what made sense for this project.

Once I had a direction, I dug into the technical side. How did other games pull this off? Thanks to my network, I was able to talk to people who worked on both Skate and Tony Hawk’s Pro Skater, and soak up every bit of insight I could.

The first goal was to align the skater smoothly to the ground, which I solved in an early skater controller prototype. After that, I focused on keeping the skater inside the pool. At first, I used invisible walls, similar to the approach in THPS, which you can see in the vert mechanic prototype.

That worked, but I wanted something more flexible. So I switched to the Skate method of velocity correction, which keeps the skater in the bowl without needing any walls. This approach made carving and speed control feel much more natural, as shown in the downhill carving and speed control test.

It also opened up new possibilities—like jumping pool gaps and landing cleanly back in the bowl—which wouldn’t be possible with the old invisible wall setup. You can see that in action in the final version with controls.

Since I decided to focus on physics-based gameplay similar to the Skate franchise, I also wanted an input system that matched that style. So I went with flick stick controls. That meant playing hours of Skate 3 to figure out how their system worked—and then giving it my own twist with a custom approach.

To make setting up tricks easier, I built a simple editor where I could define the stick patterns needed for each trick. You can see that in the input visualization and debugging tool.

Grinding on rails isn’t handled by button combos either. Instead, it’s all about which side of the board and which direction you hit the rail from, as shown in the gesture-based input for tricks.

For grab tricks, I created another custom editor. This one defines which trick to play based on stick input combined with shoulder trigger input, which you can see in the early input tests with analog stick controls.

All of this came together into a really intuitive trick system, demonstrated in the combo input system testing for advanced tricks.

The final piece was adding fail states for when players don’t finish a trick in time before hitting the ground. I didn’t want to go with a simple ragdoll, so I added fitting bail animations instead. You can see this in the player fail state and ragdoll triggered by input mistakes.

Mesh generation is one of my secret hobbies. I love building tools that make level design easier and faster. One example is a pool generator that creates geometry from a simple line, shown in the bowl mesh generator. The line itself is made from modular tiles, so every corner shares the same radius—this makes shaping complex bowls consistent and smooth, as seen in the tile-based system. After defining the layout, the tool generates a complete mesh with colliders, all handled in an intuitive editor, shown here in the final mesh generation. There's also an option to automatically generate the surrounding ground with a perfectly cut hole for the bowl, which you can see in the terrain integration example.

I also built a system for generating quarter pipes. Instead of a closed shape like the pool, you can draw the profile as a spline and adjust the points freely, as shown in the quarter pipe generator. It’s super flexible—you can move points around in real time, which makes it easy to experiment with different transitions, like in the spline editor. There are also handles to control height, allowing the quarter pipe to smoothly taper down to the ground, shown here in the height adjustment tool. You can even tweak the wall thickness on the fly by changing a single parameter, like in this thickness variation demo.

On top of that, I experimented with mesh blending tools. One approach merges basic shapes like spheres and cubes into a single surface, which you can see in this shape blending test. I also explored boolean operations for rounding corners and blending intersections smoothly, shown in this boolean rounding demo.

This is where I show the final game in action. The first gameplay test takes place in a simple level and focuses on getting the basic mechanics working. Later, I built out a full city prototype with all kinds of tricks on flat ground and smooth direction changes, which you can see in the city gameplay showcase.

One of the features I wanted was the ability to switch stances mid-air. The stance switch test shows this in action while jumping. There's also a clip of one of my favorite tricks, the Impossible, which you can check out in the Impossible trick showcase. For vert riding, I added a cinematic camera to give it more style, shown here in the vert ramp demo. I also focused a lot on pool riding. Thanks to velocity correction, landings are smooth and precise, like in the pool riding showcase.

Debug tools were a big part of fine-tuning the gameplay. The debug view shows gizmos for things like the predicted landing point, the arc of your jump, and speed indicators—super helpful for balancing tricks and landings. At one point, I also experimented with a more stylized, comic-inspired look. You can see some of those early style tests in the first comic style demo and a slightly different version in the second test, though I ended up ditching that direction pretty fast.

Finally, there’s a long gameplay sequence showing everything working together—tricks, grinding, pool riding, getting off the board, and more. You can watch the full clip here: complete gameplay showcase.