Entropy is a dark, atmospheric exploration game where the player navigates a surreal environment and uncovers its secrets through traversal, pacing, and environmental storytelling.

The project won Swedish Game Awards 2025 — Game of the Year and Best Visuals (New Talent).

Built in Unreal Engine 5 on a PlayStation 5 production branch, Entropy was a 9-week PlaygroundSquad student project developed by a multi-discipline team under a tight deadline.

During development, I stepped into a leadership role to stabilize decision-making, align the team, and keep production moving. Alongside that, I focused on exploration level design and level integration, building the foundation of the playable spaces, refining moment-to-moment flow, and supporting mechanic iteration to keep the experience coherent and shippable.

Project Info

👤 Role: Lead, Game design, Level design

👥 Team Size: 16

⏱️ Time frame: 9 Weeks

🛠️ Engine: Unreal Engine 5

Level Design

Entropy started as a playable prototype. In 9 weeks, we turned that slice into a full exploration experience, with clear progression, readable navigation in darkness, and spaces that support puzzles, story beats, and pacing.My work focused on building and iterating exploration layouts (blockouts → playtests → fixes), then integrating them into a cohesive world flow across multiple floors. The goal was simple: players should feel lost in the world, not lost in the level.

• Exploration + puzzle layouts across Floors 1–4• Navigation fixes from playtests (backtracking, blocked paths, landmarks)• Progression stability (spawnpoints, routing, build integration)

I started by playing the existing prototype to understand what already worked, and what was missing for a full game.The biggest gap wasn’t mechanics — it was readability and player guidance in a world built around darkness.

From there, I rebuilt the opening into a more intentional first exploration slice. The new start teaches that light isn’t just mood — it’s navigation.A short, controlled route rewards brief bursts of light to reveal landmarks, paths, and interactables, teaching the core loop without relying on tutorial text.

An elevator hub anchors orientation between floors, while the Return Gate (portal) keeps backtracking readable in a dark environment.

To keep navigation readable in a very dark game, we structured Entropy around a simple loop: each floor is a self-contained exploration/puzzle space, and a central hub elevator acts as the consistent anchor point.After completing a floor, players return through a Return Gate (portal), regroup in the hub, and then descend to the next stop, keeping progression clear even when visibility is limited.

Below, I break down my level design work floor-by-floor. For each floor, I’ll highlight the key goal, the main readability risk (in a dark game), and the iteration that made the route clearer through playtests.

⦿ Floor 1

Floor 1 started from an existing prototype blockout, so my first step was to play it and map what already worked. The foundation was solid, but the opening needed a clearer first-time experience, especially because darkness is the core constraint of the game.

To make the temple reveal land, the layout shifts from tight, claustrophobic navigation into a wider “breathing” space, this contrast became a key pacing beat before the player enters the structure.

Floor 1 (Part 1) — onboarding route. Gun pickup → first traversal beats → first direction anchor.

Floor 1 (Part 2) — transition toward the temple.

At the half of Floor 1, I wanted a moment where the player realizes the scale of the world. The problem was that the reveal sat in darkness, so some players rushed past it or never understood they could “probe” the space with light.

To make the moment readable without removing the mystery, I treated light as a reward for curiosity. Shooting into the void becomes a small test: how far does the orb reach? If the player is patient, the space slowly answers back, and the temple silhouette emerges as a payoff that makes the player feel small.We iterated on the light-orb behavior with programmers and artists to support that pacing: the orb travels faster over distance and keeps its brightness longer, so far areas still get a readable glow. This kept the darkness intact, but made the reveal consistent and hard to miss.

Blockout → Final Readability

This area was our first real “navigate-by-light” test, and early playtests showed players struggled to read the route.After adjusting sightlines and landmark cues, it became a strong onboarding gate — once players passed it, they adapted fast and the rest of the game flowed better.

BeforeAfter

⦿ Floor 2

Floor 2 is the first “pure temple” space. I designed it as a contained loop around a central void so players always have a clear sense of direction, even when the environment is hard to read.The focus here is pacing: short exploration beats → a puzzle beat → a platform beat, repeating in a way that feels natural and keeps forward progress obvious.

This floor teaches sequencing and timing while keeping navigation simple, one readable loop, with each beat pointing to the next.

I started with a more complex final platforming segment that required several precise placements in a row. Playtests showed it was too punishing this early, so I simplified the sequence:fewer chained steps, clearer setup, and a smoother reset if the player failed. After the change, players reached the end more consistently and entered the next floor with more confidence.

ENTROPY FLOOR 2

Blockout → Final Readability

I iterated on the blockout to make the path readable without brightening the whole level: clearer sightlines, stronger silhouettes, and a few well-placed landmarks that light could briefly reveal.After this pass, players adapted faster and the rest of the game flowed more smoothly.

BeforeAfter

⦿ Floor 3

I designed it as a controlled “reset space” after Floor 2: simple shape, limited distractions, and a clear focal direction so players naturally discover the first magnet interaction without needing explicit tutorial text. The room is intentionally contained to encourage scanning and curiosity, then rewards that curiosity with a fast, satisfying first traversal payoff.

Part 1 and Part 2 act as Floor 3’s onboarding sequence. I built them as a controlled reset after Floor 2: simple shapes, limited distractions, and a clear focal direction so players naturally discover magnet traversal without relying on explicit tutorial text.From there, I extended the space into an early route that reinforces the new movement rhythm and sets up progression into the next areas. The focus was keeping pacing tight and navigation clear, so players feel they’re gaining flow and confidence, not stopping to “solve a puzzle” yet.

Once Floor 3 Part 3 was being assembled into the full build, I focused on integration and polish.I did a cleanup pass across the floor, moved elements to improve flow and pacing, and adjusted progression edges between Floor 2 and Floor 3 (blocked paths, entrances, and guidance) so the overall difficulty curve stayed consistent.This was also where I supported clarity improvements, small feedback and layout tweaks that made the floor feel more cohesive when played as part of the complete hub-to-floor loop.

⦿ Floor 4

Floor 4 was the first “full-scale temple” slice — a large vertical space built to sell the feeling of an endless, broken structure.
My focus was establishing the foundation and route: clear long-term goals, strong sightlines across the gap, and a progression that lets the player preview future spaces, then later look back and understand how far they climbed.Because the level is more open and multi-layered, we broke it into smaller puzzle beats and validated flow through playtests. I worked mainly on the switch/magnet/platform beats and how they chain into readable traversal, while keeping the overall route linear even when the space feels free.

What I’m showing below: the starting route + a short gameplay reel, then two focused puzzle beats (each with a quick clip from a brighter debug view so the layout is readable).

Floor 4 — Part 1

I built the opening of Floor 4 to immediately communicate scale and direction. The route starts with a clear “climb” goal, then uses short, controlled traversal beats to teach how this floor flows: push forward, gain height, and repeatedly re-frame the space from new angles.A key goal here was readable progression in a complex space, the player should always know what the next objective is, even while the environment stays mysterious. This section sets up the rhythm for the rest of the floor: cross a gap, unlock the next stop, then climb again.

Floor 4 — Part 2

I designed the opening puzzling beat of Floor 4 around a new twist on an existing toolset: using switches to control freezing platforms, so the player starts “routing” movement instead of just reacting to platform timing.
It’s meant to feel like a playful bridge between the moving-platform logic and the orange freeze platforms, but with more intention and planning.

To give the beat tension and forward momentum, the route is built as a clean platforming run over hazardous spores (smoke).The space stays readable, but the floor becomes a soft threat that pushes the player to commit, keep moving, and use the switch control to create a safe path to the other side.

Floor 4 — Part 3

This section combines switches and magnets into a vertical climb where progress costs resources. The player repeatedly sacrifices orbs to unlock the next step, which creates tension and makes the climb feel risky, almost like “web-swinging” upward through the space.

A big focus was clarity through feedback: strong audio/visual cues became essential once sound came online, and it noticeably improved player confidence during playtests.This area also needed multiple iteration passes due to progression/save edge cases, but by the end, players consistently enjoyed the flow and the sense of escalation.

Blockout → Final Readability

I built the first foundation of Floor 4 as a “final floor” space: a large broken-temple chamber with long sightlines, big vertical scale, and routes that loop across separated platforms. The goal was to make players feel deep inside something massive—while still keeping the route understandable.

After playtests and team discussions, we split the floor into clearer sections and locked what each section needed to teach or combine.With the artists and programmers, the space evolved from pure blockout into a readable set-dressed environment that still supports the same traversal and puzzle intent.

For this breakdown, the “after” image uses added light so the layout and beats are readable on a portfolio page.

BeforeAfter

Mechanics / Systems Design

This chapter covers how the prototype mechanics were turned into a consistent, shippable system.My contribution was mainly systems design + tuning + usability rules: defining interaction language (sockets/switches), helping standardize platform and magnet behavior, and pushing for clear feedback (color identity + audio cues)
so puzzles stayed readable in darkness.

The orb

To avoid every object having its own special rules, I helped formalize the socket philosophy: the orb enters a socket to provide power, and connected objects react in predictable ways.This became the shared language of the game“dead” objects communicate they need power, and powered objects communicate they’re active, making cause-and-effect easier to read during playtests.

Moving & Freezing Platforms

I helped standardize platform rules so designers could build harder rooms without the platform behavior feeling inconsistent: collision reliability, movement speed expectations, and clearer identity through color. Splitting traversal intoBlue = standard movement and
Orange = timing/state control reduced confusion and made playtest feedback easier to act on.

Moving Platform (Blue)A powered platform used for traversal.

Freezing Platform (Orange)moves continuously; shooting/freezing changes its state to create safe timing windows.

Magnets

Magnets were the first mechanic that felt like it could turn Entropy into a real traversal game, but early on they were also the easiest way to confuse players.My job was to help take the prototype version and turn it into something we could reliably teach, build levels around, and scale across later floors.

Magnet traversal started as a raw prototype feature: it proved the idea, but it was hard to read and easy to lose control.Players often couldn’t tell when a magnet would grab them, or where the pull would place them, so failures felt random instead of earned.

Early on, magnets were still a rough prototype idea—powerful, but hard to read and easy to misunderstand. In our first design discussions, we kept coming back to the same question: how do we make this feel intentional instead of random?I brought up the need for magnets to communicate their rules clearly (when they activate, what they pull, and what the player can expect), especially in a game built around darkness.That became the starting point for refining them into something we could actually build levels around.

To shape the feel, I referenced two systems that make pull-based traversal readable:
Tears of the Kingdom’s orb-like movement language and Super Mario Galaxy’s Pull Star.Not to copy them but to match the clarity: you aim, you commit, and the result is easy to predict on the first try.

Weak Magnet

Designed as the “learnable” magnet. The goal was to make activation feel deliberate and readable, so weak magnets only become usable when you’re close, supported by an audio cue that pulls attention upward and encourages scanning.This makes the first magnet moments feel like discovery, not trial-and-error.

Strong Magnet

Designed as the “anchor” magnet for bigger spaces. Strong magnets give a confident sense of commitment: once chosen, they pull you with purpose and help the player plan across long gaps.The intent was to support scale and vertical travel without constantly asking the player to guess range.

Two Weak Magnets Combo

This rule was added to turn magnets into a routing tool instead of a single “grapple point.” With two weak magnets active, traversal becomes about positioning and planning.The player can shape where they’ll be pulled and create intentional mid-air paths. It’s the first step toward “Spiderman-style” movement: chaining decisions, not just reacting.

Switches & Sockets

Entropy’s interaction system is built around one clear idea: the orb “powers” the world by entering sockets.My focus was making that logic readable in darkness and reliable for level design, so puzzles feel intentional, not like guessing which object is active.Early on, I helped define and document the two socket types and the key rule: recall should cleanly undo powered states (platforms reset and spheres deactivate).

Sockets

Sockets became the visual language of interaction.
I helped shape the system into two readable categories:

Circuit Socket: temporary power. The orb can be recalled, and the connected object returns to its default state.Permanent Orb Eater: irreversible commitment. It absorbs the orb to unlock progression moments (like teleporters / gates).On the production side, I also spent time improving readability + communication for the team (clean documentation + clearer setup rules), because the system only works if everyone can build with it consistently.

Switch

My main contribution was integrating switches into real puzzles, especially in Floor 2, where I used switches as the player’s first
“I control the room” moment.The design goal wasn’t to teach a new mechanic with text, it was to create a simple loop:spot the switch → shoot → see the environment react → repeat.Because the game is dark, I pushed feedback hard:
I did quick fixes to improve the switch → platform connection feedback so playtests didn’t turn into confusion.

Permanent Switch

Permanent switches are about tension and commitment.
You’re not just activating something you’re sacrificing an orb to permanently open a path or unlock a gate.I used these as “decision points” inside levels: moments where the player understands:
“I’m choosing progression over keeping tools.”And again: because this happens in darkness, I treated readability as part of the design, giving switches extra attention with visibility and feedback so the player doesn’t miss the purpose of the moment.

Portal

After each floor, the game needed a “return beat” back to the hub. I wanted that moment to feel like re-entering something unknown, not just a simple fade-to-black teleport. The portal became a small reward and a strong punctuation mark:
“floor complete → regroup → go deeper.”

Inspiration and target feeling

I looked for a reference that felt unsettling and physical, like stepping into a machine that shouldn’t exist.Event Horizon had exactly that:
a gate that feels alive, with a rotating/vortex effect that sells danger + curiosity. The goal wasn’t to copy the movie just to match the vibe:Commit to the gate, lose your bearings for a second, then snap back into the hub.

Proof of concept

Production was already moving fast, so instead of debating forever, I built a quick proof of concept on my own time.The first version was intentionally rough:
Just enough to prove the illusion works in-engine and that the gate can become a real gameplay endpoint, not a cutscene.

From prototype to final

I tied the portal to a simple rule:
It opens only after the player deposits three orbs, so the return feels earned and reinforces the game’s “orbs power systems” language.Once the concept was proven, I requested an early art task for the gate silhouette and kept iterating until it matched Entropy’s tone.It took some convincing to ship this instead of a basic teleport, but it ended up adding a strong identity moment at the end of every floor.

Lighting & Readability

Entropy lives and dies by what the player can barely see. The orb isn’t just a flashlight, it’s the game’s navigation language, pacing tool, and mood controller at the same time.My responsibility here was protecting the core promise:
Oppressive darkness that still feels fair. Players should feel tense and curious, not confused, not punished by the screen.

Clarity without breaking the darkness

Early in development, the lighting kept swinging between two extremes in clarity:Too dim → spaces felt flat, distance was unreadable, and mistakes felt random instead of earned.Too bright / too flashy → players could “solve” navigation by spamming shots and the atmosphere collapsed.

The hardest part wasn’t making it “look good.” It was building a consistent readability language that works in a game where visibility is intentionally limited.

Visibility Iteration

The core challenge

A big part of my work was keeping the original prototype vibe as the project became more complex. Mid-production we hit a messy phase where every change affected readability, and readability changed again depending on screen brightness, room lighting, and testing setups.To stop chasing our own tail, I started treating visibility like a design system: test the same situations repeatedly, lock the mood rules, then tune values until it was readable without becoming comfortable.

Shooting to navigate

This was my main stress test: can players move forward confidently by firing orbs without over-brightening the level?• My target wasn’t “more light.” It was usable information:• Enough to read the next route + hazards• Not enough to kill the mysteryI iterated values here until the orb felt like a controlled tool, not a screen-filling flashbang.

Orb-only readability

Fun (and very real) testing insight: depending on your room lighting and screen brightness, you might not even see the final shot in the clip — and that’s intended.The game was meant to be played in a darker environment. Later, once we saw how much setups vary, we pushed for a gamma slider so players could calibrate without destroying the intended mood.

I learned that lighting in a dark game isn’t decoration, it’s level design. The goal is not visibility, it’s trust: the player should believe the game is fair even when it refuses to show everything.

The bugs

Early on, my readability relied more on direct markers (decals / “painted” guidance).It worked, but it felt too artificial for Entropy’s tone like the level was labelled instead of discovered.
The goal became: keep guidance, remove signage.I wanted players to feel guided without noticing the guiding.

A teammate originally pitched the bugs as atmosphere + threat, but we realized they could also become a diegetic navigation language.
My contribution was using them intentionally as soft landmarks:

The hard part was balancing mood vs clarity.
If bugs were too strong or too consistent, they became obvious arrows. If they were too subtle, they didn’t help at all.The Bugs should support decisions, not replace them, players still explore, but they stop getting lost for the wrong reasons.

Challenges & takeaways

Entropy’s biggest challenge was keeping the game fair and readable while everything was still shifting mechanics, lighting, pacing, and late production polish.A lot of my work became “protect the experience” work: turning playtest confusion into clear rules (feedback cues, door/switch visibility, beam clarity), stabilizing progression across floors so players always knew what to do next, and making hard scope/pacing cuts when something was too early or too punishing.When alignment was missing (like the hub return/portal), I learned that the fastest way to unblock decisions is a playable proof-of-concept, not more discussion.The main takeaway: in a dark exploration game, readability isn’t decoration, it’s level design and system design combined, and the final quality comes from consistency, glue-work, and iterative fixes more than new ideas.

Swedish Game Awards

Swedish Game Awards 2025 was the moment Entropy stopped being “just a school project” and became something real.In 9 weeks, our team shipped a complete game and it ended up winning Game of the Year (New Talent) and
Best Visuals (New Talent).
For me, it’s proof that I can help turn a prototype into a finished, presentable experience under real deadlines.

The team behind Entropy
Nine weeks of chaos, testing, and finishing together.

The Lightkeepers

After the gala, what stuck with me was how real it suddenly felt, people outside our team reacting to the game like it was already out in the world.The award means a lot because it represents the whole journey: making hard choices, testing, cutting, polishing, and still protecting the core vibe. That’s the part of development I want to keep doing.