Before opening Unreal Engine. Before creating a project. Before creating any assets.
This is where I want to start.
JRPGs are not just a camera angle, a turn-based menu, or a nostalgic art style. They are systems-heavy games built on layers of intentional design decisions. If those decisions are unclear at the start, no engine — Unreal included — will save the project later.
This blog is my attempt to document the thinking behind building a JRPG in Unreal Engine, starting with theory and moving gradually into implementation. This is not a step-by-step tutorial. It’s a design log — a place to reason through ideas, constraints, mistakes, and trade-offs as the project evolves.
Why Start With Theory?
Unreal Engine is extremely good at letting you build things quickly. That’s also its biggest trap.
You can prototype combat, movement, UI, and environments long before you’ve answered the most important question:
What kind of JRPG am I actually trying to make?
Starting with theory forces clarity. It helps define scope, protects the project from feature creep, and gives every future technical decision a reason to exist.
More importantly, it creates a reference point. When the project inevitably gets complicated, I can come back here and ask:
Does this still align with the game I set out to build?
What Do We Mean by “JRPG”?
“JRPG” is often used as shorthand for turn-based combat, anime-inspired visuals, or nostalgia for a specific era of games. While those elements are common, they are ultimately surface-level traits. They describe how a game looks or feels at first glance, not how it is designed or why it works.
At a deeper level, a JRPG is defined by structured systems deliberately designed to work together. These games are less about moment-to-moment mechanical skill and more about planning, comprehension, and long-term decision-making. Progress comes from understanding systems, not mastering reflexes.
Below are the core components that, together, form the foundation of a traditional JRPG.
A Clear Combat Loop
The combat loop defines how players engage with enemies, make decisions, and receive feedback. In JRPGs, this loop is usually explicit and readable.
- Turn-based systems pause the action entirely, giving the player time to evaluate options and consequences.
- ATB (Active Time Battle) systems introduce time pressure while retaining turn-based decision-making.
- Hybrid systems blend real-time elements with turn structure to create urgency without abandoning strategy.
Regardless of implementation, the key idea is that combat follows rules the player can learn. Outcomes should feel earned, not random or reaction-based. The loop must be consistent so players can form strategies across multiple encounters.
A Strong Progression Model
Progression is the long-term reward structure that keeps players invested beyond individual battles.
This usually includes:
- Levels that represent overall growth
- Stats that clearly influence outcomes
- Equipment that modifies roles or playstyles
- Skills or abilities that expand tactical options
In JRPGs, progression is not just about becoming stronger — it’s about unlocking new ways to think. A well-designed progression system changes how the player approaches combat, party composition, and resource management over time.
Intentional Party Design
Unlike many Western RPGs that focus on a single customizable protagonist, JRPGs often emphasize the party as the primary unit.
Each character is designed with:
- A defined role (damage, support, control, utility)
- Mechanical strengths and weaknesses
- Synergies that reward thoughtful combinations
Good party design ensures that characters are not interchangeable. Identity is reinforced mechanically, not just narratively. When a character joins or leaves the party, it should meaningfully affect how the game is played.
Narrative Through Pacing and Structure
JRPG storytelling is not delivered solely through dialogue or cutscenes. It is reinforced by how the game is structured.
- Story beats are placed between gameplay segments intentionally
- New mechanics often arrive alongside narrative milestones
- Difficulty and system complexity ramp in parallel with the plot
This creates a rhythm where gameplay and story support each other. The player is rarely asked to choose between narrative and mechanics — progression in one usually advances the other.
A World That Encourages Forward Momentum
JRPG worlds are typically designed to move the player forward rather than let them wander indefinitely.
This does not mean the world is small or restrictive, but that it is curated:
- Areas unlock in a controlled order
- Backtracking is purposeful, not constant
- Optional content exists but does not overwhelm the main path
Forward momentum keeps pacing tight and ensures that systems are introduced at the right time. The player is guided, not constrained.
Classic JRPGs succeed not because they are large or complex, but because they are coherent. Combat, progression, narrative, and world design all reinforce one another. No system exists in isolation.
This project treats “JRPG” as a design language, not a genre checklist. The goal is not to copy existing games, but to understand the principles that made them work — and apply those principles intentionally within Unreal Engine.
Constraints: The Game I’m Not Making
One of the most important steps in any long-term project is deciding what not to do.
This JRPG is not:
- An open-world game
- A photorealistic experience
- A fully voice-acted narrative
- A branching, choice-heavy RPG
- A AAA-scale production
These constraints are intentional. They exist to protect the project from collapsing under its own ambition.
Every limitation narrows the problem space and increases the chance that the game actually gets finished.
Core Design Pillars
These are the rules that future decisions must answer to. If something doesn’t support these pillars, it doesn’t belong in the game.
1. Readable Systems Over Realism
Players should understand why something happened in combat. Numbers, effects, and outcomes should be clear and predictable — even when they are complex.
2. Turn-Based Combat With Intent
Turns are not filler. Each decision should matter. Combat should reward planning, party composition, and understanding mechanics rather than reaction speed.
3. Small Party, Strong Identities
A smaller cast allows deeper mechanics per character. Each party member should have a clear role, strengths, and weaknesses.
4. Stylized Presentation Over Fidelity
The goal is clarity and cohesion, not realism. Visual style exists to support gameplay and readability.
5. Finishable Scope
Every system is designed with completion in mind. A smaller, polished experience is preferable to a large unfinished one.
Why Unreal Engine for a JRPG?
The choice of engine is not about genre convention — it’s about whether the engine supports clear systems, iteration, and cohesion.
Key reasons for choosing Unreal:
- Blueprints enable rapid prototyping and tuning of combat flow, UI logic, and game states.
- C++ provides a solid, deterministic backbone for core systems like turn resolution, stat calculation, and ability execution.
- Data Assets and Data Tables are a natural fit for JRPG-style data: stats, skills, items, enemies, and status effects.
- State Machines map cleanly to turn-based combat, where gameplay is best expressed as a series of clear, readable states.
- UMG allows fully custom, information-dense UI — essential for menus, combat screens, and progression systems.
Beyond gameplay systems, Unreal’s production tools reduce overhead:
- Fab and Megascans accelerate environment and asset creation.
- Sequencer supports in-engine cutscenes and narrative pacing.
- MetaHumans provide a strong starting point for character models and animation, even if later stylized.
That said, UI-heavy workflows and turn-based logic require deliberate structure. This blog will document how those challenges are approached rather than glossing over them.
A High-Level Systems View
At a conceptual level, the game can be broken into a few core systems:
- World exploration
- Encounter triggering
- Combat state management
- Reward and progression loops
- Narrative delivery
Each system should be loosely coupled but clearly defined. The goal is to avoid a single monolithic “RPG system” and instead build smaller, understandable parts that work together.
No code yet — just mental models.
What Comes Next
With the theoretical foundation in place, the next steps will focus on turning ideas into structure:
- Defining the combat flow on paper
- Designing a data-driven stat system
- Deciding how party turns are managed
- Mapping combat states in Unreal
Only after that will I open Unreal Engine and start building prototypes.
This project starts with intent — and this post is that starting point.