Introduction

Cocoon arrives like a tiny, determined beetle with a PhD in spatial optics: small protagonist, sprawling cosmic idea. On PS5 the game presents itself as a polished, tightly directed puzzle-adventure built in Unity by Jeppe Carlsen's Geometric Interactive. The conceit is simple but deceptively fiddly: you find orbs that contain entire micro-worlds, hop in and out of them, and use those worlds - and the orb's functionality - to solve layered mechanical puzzles. Critics loved it (PS5 Metacritic sits at 90/100), and it's easy to see why from a systems-and-implementation perspective. This review approaches Cocoon as if it were a neat little machine: what are the moving parts, how well do they interlock, and how often will one of those parts jam and require a restart?

Gameplay

Cocoon's core gameplay loop is a study in constrained systems. The avatar is a small insectoid entity with limited direct actions (move, hop, interact), but it gains agency through orbs: each orb equals a contained world, an active ability, and a puzzle domain. From a mechanical standpoint the orb is both a state container and an input device. It holds a subscene with its own set of entities and physics-affecting rules, and the player can inject the orb's state into the overworld to power lifts, platforms and mechanisms. Technically this is interesting because it foregrounds scene composition and cross-scene interactions. The design centers on 'spatial relationships between interconnected realms' - in practice that means the game needs a reliable mapping between orb-local coordinates and global space, deterministic state transfer for puzzle objects, and robust handling of edge cases when players manipulate objects mid-sync. On PS5 I found the transitions between worlds crisp: there's no awkward object snapping or desync where an object appears in two places at once, which suggests a careful implementation of serialization and authoritative state change when swapping realms. Unity's scene management and a custom state machine for orbs seems like the likely backbone here. Puzzle design itself trades brute force logic for layered affordances. Many puzzles are solved by chaining orb abilities: the orb activates a machine that moves a platform in the main scene, which in turn shifts an orb's internal layout, unlocking a new path back in the orb world. From an engineering view this is effectively a cascade of event-driven triggers; each trigger exposes only a small portion of the solution space so the player reasons about local cause-and-effect rather than trying to brute-force everything. That keeps complexity manageable and reduces combinatorial explosion of possible states. Boss encounters wrap these mechanics into time-constrained interactions where the enemy is impeded rather than directly damaged. The restraint is notable: you never get a sudden, unrelated mechanic during a boss - the boss is an emergent extension of the orb/overworld choreography. This makes boss code simpler and cleaner because the encounter reuses existing subsystems instead of introducing new ones mid-game. Control and camera deserve a practical mention. The game is presented in third-person on a mostly fixed camera plane; this prevents many common navigational headaches in spatial puzzle games because the camera frames the action in the way the puzzle expects. Collision is intentionally tight and predictable; since most puzzles rely on precise positioning and timing, you rarely find yourself blaming a slippery collision hull or jittery physics. Movement input maps reliably to outcomes, which is a quietly important technical achievement in puzzle design. Cocoon was at one point intended as a sidescroller during development, but the move to a top-down/third-person framing amplified the satisfaction of 'traveling between worlds'. That change also simplified the technical stack: top-down framing reduces occlusion, makes hit detection less ambiguous, and limits camera-driven edge cases that plague 3D platformers. The development decision here is pragmatic as well as artistic - better perception equals fewer unexpected player states.

Graphics

On PS5 Cocoon is a masterclass in aesthetic-driven technical choices. The art direction leans organic and slightly grotesque: gloopy membranes, vessel-like textures, and twitching appendages. Graphically, that look is achieved through a combination of stylized texture work, carefully tuned material properties, and modest use of post-processing. Instead of chasing photorealism the team leaned into shader-driven surface detail: subsurface scattering approximations, layered noise for wet/viscous surfaces, and normal-mapped deformation to sell the squelchy biology. That keeps GPU costs predictable while delivering a dense, tactile look. Because Unity is the engine, you can see sensible optimization trade-offs. Draw calls are conservative in non-interactive areas, and the game favors medium-complexity meshes with rich materials over extremely dense geometry. Level streaming and asset bundling must be working cleanly - transitions into orb worlds are immediate and artifact-free, which implies prefetching and async load operations that mask hitches. The PS5's IO throughput helps, but the design choices (moderate texture memory, reusing shader variants) ensure a smooth experience even on consoles without bleeding-edge resources. Animation and particle work are small but effective. Enemy and environmental animations are clamped to the puzzle rhythm: they're expressive enough to be readable as puzzle-signaling without taxing the animation system. Particle systems are used sparingly for feedback - splashes, pheromone-like trails, and mechanic-driven sparks when a machine engages - which preserves GPU headroom. Lighting is atmospheric rather than dynamic-heavy: mostly baked or mixed lighting with careful emissive elements for contrast. This reduces runtime cost and keeps frame pacing stable. Audio in Cocoon is an explicit technical statement. The entire soundscape is synthetic, composed of generated noises and modular synth textures rather than sampled recordings. That choice interacts with gameplay because audio cues become deterministic and easy to mix programmatically; if an orb activates a machine, a specific synthesized timbre can be triggered and attenuated based on distance and state. Jakob Schmid's score and the dampened piano glissandi that critics noted sit neatly in the procedural design, which both enhances immersion and simplifies runtime audio processing compared to a heavy sampled pipeline.

Conclusion

Cocoon is a tight, technically savvy puzzle-adventure that prioritizes deterministic systems over flashy complexity. On PS5 that translates to seamless world-switching, predictable physics and input, and artful performance tuning that emphasizes shader-driven visuals and synthetic audio. Its puzzles are engineering-minded compositions - small subsystems interacting in layered ways - and the game benefits from design choices that minimize accidental player confusion (camera framing, limited control ambiguity, reuse of mechanics for bosses). If you care about how games are built as much as how they play, Cocoon is a lovely example of form following function. It shows how deliberate constraints - an insect protagonist, containerized orb worlds, synthetic sound design - can produce a cohesive, memorable experience. The result is a game that feels handcrafted at the technical level: optimized where it needs to be, expressive where it counts, and never noisy in ways that undermine the puzzles. For technical purity and measured creativity combined, Cocoon earns a solid 9/10 on PS5: a small machine that hums beautifully.

See Latest Prices for Cocoon on PS5 on Amazon

See Prices for Cocoon on PS5 on Ebay