Lies of P game development: how a Soulslike action RPG was built around a puppet protagonist
Lies of P is a third-person action RPG released by NEOWIZ and developed by Round 8 Studio, running on Unreal Engine and clearly positioned inside the Soulslike genre while wrapping its combat systems around a reimagined Pinocchio story set in a Belle Époque industrial city called Krat. The project blends established genre mechanics with a bespoke weapon assembly system, a lie-based morality layer, and a stylised art direction that borrows from European automata, Art Nouveau, and steampunk visual references. The result is a title that had to satisfy genre veterans, deliver a coherent narrative through a branching choice system, and run with stable frame rates on consoles that range from base last-generation hardware to mid-range PCs.
This article focuses on the production and engineering decisions that shaped Lies of P, drawing on the game’s own credits and patch notes, public studio interviews, and its public background entry on Wikipedia, which provides useful release, setting, and reception context for the title. The goal is to explain how the core systems were designed, what tradeoffs the team accepted, and what other developers can take away from the choices made on this project.
Engine choice and rendering pipeline
Round 8 Studio built Lies of P on Unreal Engine, the same engine used by many other Korean studios shipping mid-budget action titles. That choice brings several concrete consequences for production. The team inherits a mature animation system, gets access to a large library of marketplace content for prototyping environment pieces, and benefits from Epic’s continuous engine updates. It also means the project has to fit inside Epic’s licensing terms and respect Unreal’s content update cadence, which forces a careful pin on a specific engine branch during the heavy production months.
The rendering pipeline in Lies of P is built around a deferred renderer with screen-space reflections, dynamic lighting driven by a combination of baked lightmaps and real-time sources, and a volumetric atmosphere layer for the heavy fog that fills the city streets. The game is not marketed as a path-traced production, so the team can keep the lighting cost manageable on consoles while still selling the heavy industrial atmosphere that Krat demands. The fog and the smoke together carry a lot of the visual identity, which is a useful trick because volumetric layers scale more gracefully across hardware tiers than full real-time global illumination does.
One rendering decision worth noting is the careful treatment of metal and brass surfaces. The art direction repeatedly puts the player in front of polished metalwork, clockwork devices, and oil-slicked iron, and the material graph has to balance reflectivity against frame cost. The team appears to have leaned on tiered material quality settings for the different console tiers, with a cheaper shading model reserved for the base hardware target. This is a common pattern in Unreal projects that need to scale across hardware generations without forking the renderer.
Post-processing is another area where the project makes pragmatic choices. The team relies on temporal anti-aliasing and a temporal upscaler to hit stable output resolutions, with screen-space effects such as bloom, depth of field, and chromatic aberration kept at conservative cost on lower tiers. None of this is novel by itself, but the combination is what allows the game to ship on three distinct console tiers with a single renderer configuration.
Combat systems: a Soulslike built around weapon assembly
The combat in Lies of P inherits the core loop of stamina-managed melee, lock-on targeting, i-frame dodges, and posture-style defense. Where it diverges is in the weapon assembly system. Rather than locking players into fixed weapon archetypes, the game lets you combine a handle and a blade into a custom weapon. Each component contributes to scaling values, weight, and moveset fragments, which creates a build diversity that the genre does not always allow.
This is a real engineering challenge because animation has to blend across many component combinations. The team uses a layered animation approach: the handle dictates the grip, idle, and running animations, while the blade drives the attack chain and weapon-specific vfx. The split is familiar from other Unreal-based action games, but the density of combinations in Lies of P pushes the asset team to maintain a clean naming and version control convention for every component, because a single misnamed asset can break an entire weapon family during regression testing.
| System | Design intent | Engineering implication |
|---|---|---|
| Handle and blade assembly | Build diversity without class locking | Split animation ownership between handle and blade |
| Legion Arms | Secondary gadget slot for ranged and utility | Separate animation layer and cooldown state |
| Stamina and posture | Classic Soulslike pressure loop | Shared simulation tick with i-frame dodge timing |
| Guard Regain | Risk-reward on perfect blocks | Frame-perfect input window checked on block |
| P-Organ upgrade tree | Player progression and build identity | Data-driven upgrade nodes with animation triggers |
The Legion Arms system adds a second combat layer on top of the assembled weapon. Players can equip a ranged gadget such as a flamethrower, a grappling hook, or a taser, and each one introduces a new animation layer, a separate cooldown, and a set of visual effects. The animation team has to keep all of these layers compatible with every weapon combo, which is a classic case of combinatorial growth in animation testing. In practice, that means the QA matrix has to cover at least one representative weapon from each handle archetype against every Legion Arm, otherwise regressions slip through into patches.
Guard Regain rewards players who perfectly time a block. Mechanically, the system checks a narrow input window relative to the enemy’s attack impact, then refunds a portion of the weapon’s stagger damage or stamina. The risk-reward loop is a deliberate design tool to push players away from passive turtling and toward aggressive defense. Tuning this window is one of the harder balance problems on the project, because a window that is too generous trivialises boss fights and a window that is too narrow removes the reward entirely.
Stamina, posture, and i-frames share a single simulation tick, which is the standard approach for the genre but still has to be tuned carefully on Lies of P because the weapon assembly system changes the per-weapon stamina cost. The team has to model stamina cost as a function of weapon weight and animation length, then validate that no weapon class becomes strictly dominant. Data-driven tuning sheets help here, because the balance team can adjust a single coefficient and re-test the affected weapon families without rebuilding the encounter.
Narrative systems: lies as a game mechanic
One of the most distinctive production decisions in Lies of P is the use of the protagonist’s lies as a branching mechanic. The Pinocchio frame story normally rewards truth, but here the player is asked to lie, and the game tracks how often the player lies across the campaign. The result is a human-mechanics layer that influences NPC disposition, available quest branches, and the final ending. This is a deliberate inversion of the source material, and the writing team had to map every response option to a truth-value, a downstream consequence, and a flag in the quest state graph.
The branching structure is light compared to a dedicated narrative RPG, but it is heavy enough to require a centralized quest system. The studio uses a flag-based progression graph where each major NPC tracks a counter of truths and lies, and the system resolves quest state at the end of each chapter. The ending is then chosen from a small set of fixed branches driven by the cumulative lie count and a small number of specific quest completion flags. Designers have to think about counter thresholds the same way a stat-heavy RPG designer thinks about level curves.
For a development audience, the takeaway is that even a narrow branching layer introduces a long tail of QA work. Every branch has to be tested for at least one completion, every NPC disposition has to be verified, and the localization team has to keep all branches consistent across languages. For additional context, Adding more lie or truth options raises QA cost roughly linearly, which limits how much the designers can expand the system without rethinking the underlying data model. When the team added the new ending through the paid DLC, the same constraint applied: the new ending had to slot into the existing graph without invalidating the older branches.
Voice acting and localization also have to absorb the branching layer. The recording schedule has to cover every response option in every supported language, which is a real budget line. A common workaround in this genre is to allow repeated generic responses for low-impact branches and reserve fully recorded dialogue for the high-impact flags. Lies of P follows a similar pattern, with most NPC conversations resolving into a small set of voiced outcomes driven by the counter.
Art direction, environment, and animation
Krat is the most distinctive production asset in Lies of P. The city blends Belle Époque architecture with industrial machinery, gas lamps, automata, and a creeping puppet apocalypse. The art team used a mix of modular kit pieces and bespoke landmark geometry to build districts that feel coherent but distinct. A common pattern in Unreal-based open districts is to author the bulk of the geometry from a kit and then hand-author a small number of hero pieces that break repetition. The visual identity of Krat suggests this exact approach, with the same brick profiles and street furniture reused across districts and a smaller set of bespoke landmarks tying each area to its story beat.
Character animation is another area that benefits from the choice of subject. The player character is a puppet, which gives the animation team a mechanical excuse for stiff movement, fixed facial plates, and the segmented limb motion that the enemies share. This deliberate choice simplifies the animation budget because the characters are not expected to carry a full range of facial motion. At the same time, the team has to keep the motion readable, because stiff animation can quickly read as broken rather than intentional. Combat readability is the constraint that drives most of the player puppet’s motion design.
| Art domain | Constraint | Production pattern |
|---|---|---|
| Environment kit | Large districts, repeated geometry | Modular kit with hand-authored landmarks |
| Material work | High metal and glass density | Layered roughness and reflection cost tiers |
| Enemy animation | Puppet and human hybrid enemies | Shared rigs with mechanical overlays |
| Player puppet | Limited facial performance | Mechanical posing and gestural acting |
| Lighting | Atmospheric horror with readable combat | Baked base light with selective real-time |
Lighting is a recurring constraint in horror-leaning action games. The team has to keep the player readable during combat while also selling the oppressive atmosphere outside combat. Lies of P solves this with a contrast-managed lighting pass that pulls the player’s puppet and active enemies above the background luminance, then drops the global lighting back down for traversal. This is a contrast budget rather than a brightness budget, and it is one of the cheaper ways to keep both readability and atmosphere in the same scene.
Enemy variety is built on a shared puppet rig with mechanical overlays. The animation team authors a base skeleton that handles locomotion and idle behaviour, then layers on weapon-specific attack chains and puppet-specific flourishes. This pattern keeps the asset count manageable while still giving each enemy archetype a distinct silhouette, which is the cheapest way to make a Soulslike bestiary feel fresh without multiplying the production budget.
Performance, scalability, and platform targets
Performance is one of the more useful case studies in Lies of P because the game ships on last-generation consoles, current-generation consoles, and PC. The team has to deliver a stable experience across three different performance envelopes, which forces a scalable rendering pipeline and a conservative asset budget per scene. The PC tier adds a fourth envelope, because the range of hardware in the Steam user base is wide and the team has to defend the minimum spec without crippling the high end.
The most common optimization pattern in Unreal projects of this kind is to split the rendering cost into tiers, then expose each tier as a console variable. Lower tiers reduce shadow resolution, drop volumetric density, and reduce the number of dynamic lights. The base last-generation tier typically runs at a lower internal resolution and relies on temporal upscaling to hit a 1080p or 1440p target. The current-generation tier can run at higher internal resolution and use a more aggressive post-process stack. The PC tier exposes most of the same knobs to the user and adds a few quality-of-life toggles such as variable rate shading and dynamic resolution.
- Profile representative scenes early, not just the final boss arena. CPU and GPU bottlenecks often appear in dense city streets long before they appear in arenas.
- Use a single scalability curve for the open districts and a separate one for boss arenas, because the workload mix is different.
- Keep a fallback material variant for every metallic surface so the lowest tier can swap in a cheaper shading model without rebuilding the scene.
- Test lighting under thermal load. Console performance drops under sustained load, so a scene that holds 60 fps in a 30 second test can fall below target after two minutes.
- Use temporal upscaling rather than dynamic resolution when the visual identity depends on stable geometry. Dynamic resolution is fine for particle-heavy scenes but reads poorly on crisp metalwork.
One subtle point is that Lies of P has several boss arenas with very high enemy density and complex vfx. These arenas push the simulation harder than the open city, so the team has to either scope the encounter complexity down or accept lower frame rates in those moments. Most studios shipping in this genre pick the second option and then communicate it through performance reviews, because reducing the visual identity of a signature boss is a worse outcome than a one-off frame dip.
Loading and streaming are a separate axis of performance. The team has to keep the open districts streaming without long hitches, which means the asset budget per district has to be measured against the streaming budget on the lowest tier. A common approach is to author each district with a target triangle count and a target texture pool, then validate that the worst-case district still streams within the platform’s I/O budget. Lies of P uses a similar pattern, with relatively tight district budgets and a small number of hand-tuned hero scenes that exceed the budget on purpose.
QA, balancing, and difficulty curves
Soulslike games are notoriously hard to QA because the difficulty curve is the product. A balance change in the early game can ripple through every later encounter because the player has fewer resources, fewer upgrades, and a smaller margin for error. Lies of P has a long, mostly linear structure with a few optional bosses, which simplifies the QA matrix compared to a true open-world Soulslike, but the team still has to validate that every weapon assembly and every Legion Arm remains viable across the campaign. A weapon that is too strong in the first chapter can trivialize the final boss, and a Legion Arm that is too weak gets ignored entirely, which makes both the data and the playtest feedback harder to interpret.
QA in this project is split into combat playtesting, progression validation, and regression sweeps after every patch. Combat playtesting focuses on tuning the stamina cost, the posture damage, the i-frame duration on dodge, and the recovery frames on heavy attacks. Progression validation walks the full quest graph with different lie and truth paths to confirm that every branch resolves. Regression sweeps re-test every boss and every weapon combo after a balance patch, and they are the most expensive part of the QA budget because the test matrix grows with every weapon and Legion Arm added.
One useful pattern the genre has adopted is data-driven tuning. Instead of editing every encounter by hand, the team exposes a small set of knobs in a tuning sheet and lets the designers iterate. This is a real cost saver when the team is shipping patches, because a single tuning pass can rebalance a whole encounter family. The same pattern is used for the P-Organ upgrade tree, where individual nodes are exposed as tunable values and the balance team can adjust the cost of a node without touching the rest of the tree.
Player feedback is filtered through a separate process. The team collects patch telemetry, forum threads, and video evidence, then weighs each report against the tuning data. A complaint that a boss is too hard gets checked against the average death count on that boss, and a complaint that a weapon is too weak gets checked against the usage rate. This kind of cross-checking is what keeps the difficulty curve honest, and it is one of the more transferrable patterns in the post-launch support of a Soulslike.
Live operations, patches, and DLC
After release, the studio has shipped several balance patches, quality-of-life updates, and a paid DLC expansion. The patch cadence is a useful signal for any studio planning a Soulslike release, because the genre is highly reactive. Players discover broken combos, sequence breaks, and unintended cheese strategies within days of release, and the studio has to keep a small hotfix team on standby for the first month. The first patch in particular tends to fix the most embarrassing regressions, and the second patch tends to focus on the more contested balance issues.
From a production perspective, the team has to keep the build configuration for the live version and the patch version in lockstep. That means the patch branch has to be able to ship without breaking the live branch, and the studio has to keep a stable test pipeline for both. This is a standard pattern for live games, but the stakes are higher when the player base expects the genre to feel precise. A single frame of extra recovery on a heavy attack can be enough to break a boss fight, so the QA pass on every patch has to cover the encounter list end to end.
The DLC adds new weapons, a new area, and a new ending path. The new ending has to slot into the existing narrative state graph without breaking the prior endings, which is a real test of how cleanly the team modeled the original branching system. When the original narrative data is well structured, the DLC team can add a new flag, a new counter, and a new ending resolver without touching the existing branches. When the data is messy, the DLC has to ship a refactor first, and that refactor is a real cost line because it touches the test matrix for the original campaign.
Long-term, the live operations work feeds back into the design language. The team learns which mechanics the player base enjoys, which ones get ignored, and which ones create support tickets. That information shapes the next project in a way that the original design document could not, because it is grounded in real telemetry rather than designer intuition. For a studio planning a Soulslike follow-up, the post-launch data on Lies of P is arguably more useful than the pre-release design pitch.
Lessons for other studios
Lies of P is a useful production reference because it sits at the intersection of a familiar engine, a saturated genre, and a distinctive aesthetic. The team did not try to reinvent the underlying combat loop, which is the right call for a studio entering a mature genre. The differentiation came from the weapon assembly system, the lie mechanic, and the Art Nouveau industrial aesthetic. None of those choices required a custom engine, but they did require disciplined animation, narrative data, and art pipeline work. The lesson is that genre differentiation is rarely a question of engine choice and almost always a question of system design.
For studios planning similar projects, the most useful patterns are: pick the engine you already know, focus the differentiation on a small number of systems, scope the narrative branches so the QA cost stays predictable, and design the art pipeline around modular kits with hand-authored landmarks. The genre will tolerate a learning curve, but it will not tolerate unstable performance or a broken ending. Both of those failure modes are visible to the player base within hours, and both of them dominate the post-launch conversation.
For a deeper look at how combat and Soulslike design are built in the genre, the Game Informer Lies of P tips and mechanics guide is a useful companion read, since it walks through the same systems described above from a player’s perspective and includes specific notes on stamina, posture, and boss windows.
One last note on team size. Round 8 Studio is a mid-size Korean studio, and the production patterns in this article are realistic for a team of that size. A larger studio could afford a custom engine and a dedicated narrative team, and a smaller studio would have to cut either the branching narrative or the weapon assembly system to ship on time. The patterns described here are calibrated to a mid-size studio, and they do not transfer cleanly to a different team size without re-scoping.
What to watch in future updates
Looking forward, the most interesting question for the genre is whether the studio can keep the mechanical identity intact while expanding the content. A second DLC or a sequel would test whether the weapon assembly and lie systems can scale beyond the original campaign without losing readability. The team has already shown that the data model can absorb new endings, so the next test is whether the combat designers can keep the assembly and Legion Arms combinations balanced as the content surface grows. Every new handle and blade added to the system has to be tested against the existing roster, and the QA cost grows roughly with the square of the new content count.
For developers following the title, the open questions are: can the DLC team add new weapons without breaking the assembly layer, can the narrative team add a third ending without a quest graph refactor, and can the performance team keep the high-density boss arenas within the console frame budget. Those three questions cover most of the long-term risk for a Soulslike in this size range, and they are the same questions a follow-up project would have to answer from scratch.
There is also a softer question about audience expectation. The player base for Lies of P arrived expecting a Pinocchio story, and the game delivered a darker reading of the source material. A follow-up would have to decide whether to lean further into the dark reading or to return to the lighter tone of the original fairy tale. Either choice has production consequences, because the art direction and the enemy design both have to follow the tonal decision.
Frequently asked questions
What engine does Lies of P run on?
Lies of P is built on Unreal Engine, the same engine used by a number of other Korean studios for mid-budget action titles. The choice gives the team access to Unreal’s animation system, deferred renderer, and marketplace ecosystem, while requiring careful version control and material tiering for cross-generation console support.
How does the weapon assembly system work in Lies of P?
Players combine a handle and a blade to create a custom weapon. The handle drives grip, idle, and run animations, while the blade contributes scaling values, weight, and attack animations. The two parts together produce a moveset, a stagger profile, and a visual identity. The combination system is the game’s main answer to build diversity inside a genre that normally locks players into fixed archetypes.
What are Legion Arms in Lies of P?
Legion Arms are a secondary gadget slot that the player can swap in and out. Each one introduces a new animation layer, a separate cooldown, and a set of vfx. Examples include a flamethrower for crowd control, a grappling hook for repositioning, and a taser for stagger damage. The slot is one of the main build identity choices for the player.
How does the lie mechanic affect the story?
When NPCs ask Pinocchio a question, the player can choose to lie or tell the truth. The game tracks a running count and a per-NPC disposition. The cumulative counter and a small set of specific quest flags determine which ending the player receives. The system is narrow by design so the QA cost stays predictable.
Why is Krat designed as a Belle Époque industrial city?
The art direction uses European automata, Art Nouveau, and steampunk visual references to give the world a distinctive identity. The city is full of polished brass, gas lamps, clockwork devices, and ironwork, which gives the material team a clear shading brief and gives the lighting team a clear atmosphere to deliver.
How does the team handle performance on older consoles?
The game uses a scalable rendering pipeline with console variables that control shadow resolution, volumetric density, and dynamic light count. The lowest tier relies on temporal upscaling to hit a stable output resolution, while the highest tier can run at higher internal resolution with a more aggressive post-process stack.
Is the difficulty in Lies of P harder than other Soulslikes?
The game is balanced around the same general loop as other entries in the genre, with stamina-managed melee, i-frame dodges, and posture damage. The guard regain system rewards perfect blocks, which makes defensive play viable. The team has shipped balance patches since release to address the most common pain points.
What is the P-Organ system in Lies of P?
P-Organ is the player’s upgrade tree. It exposes nodes that improve the puppet’s combat stats, expand Legion Arm capacity, and unlock passive abilities. The tree is data-driven, so the balance team can tune individual nodes without rebuilding the surrounding systems.
How does the studio keep the DLC compatible with the original endings?
The narrative state graph stores endings as a small set of resolved branches driven by lie counts and quest flags. When the DLC adds a new ending, the team adds a new flag, a new counter, and a new resolver. As long as the original data model was clean, the DLC team does not have to touch the existing branches.
What is the most useful pattern for a studio building a similar game?
The most useful pattern is to keep the underlying combat loop familiar and focus the differentiation on a small number of systems. In Lies of P that means the weapon assembly, the Legion Arms, and the lie counter. The team also scopes the branching narrative so the QA matrix stays small, and uses modular environment kits with hand-authored landmarks for the art pipeline.
Leave a Reply