A method designed to create real developers

Onboarding is the gateway to the academy and is designed as a fully practical module, not just a simple user guide. Here we not only show you how to navigate the platform, but we integrate you from the very first moment in the professional development logic that follows the whole training. You will learn how to use the frameworks, how projects are structured, how the GitHub system works with educational updates, and what role each category plays in the training ecosystem. This module is based on an applied learning methodology: everything you see is used, and everything you do has real purpose in your progression as a developer.

The Onboarding roadmap is designed for you to understand and master the system that underpins the entire academy. It includes:

• ✔️ Visual explanation of the frameworks architecture (general + by genre)
• ✔️ Introduction to the system of training modules, their progression and how they connect with one another
• ✔️ Accessing and configuring private repositories via GitHub, with step-by-step guide
• ✔️ How to follow the training asynchronously, without losing the technical thread
• ✔️ Using the student dashboard, suggested routes according to your level, and how to interact with extra content or live events

Onboarding is designed for all profiles, whether you are an absolute beginner or if you already work with Unreal Engine and want to adapt to PlatanoGames' approach. It is not generic content: we give you tools, criteria and strategies that we apply in real project development. If you are just starting, we accompany you step by step in the configuration, understanding of flows and efficient use of the platform. If you already have experience, this module helps you to quickly integrate into the professional logic we use: reusable frameworks, separation between visual and backend logic, versioning of training content, and production structure.

Everything you learn in this module will be applied from day one. You will know how to move through the frameworks, how to clone repositories to work on your copy, how to follow the live documentation in Notion and how to take advantage of each module according to your needs. For example, if you are learning UI systems, you will know where to find them, how they integrate with other systems such as the Inventory or the Pause system, and how they are updated within the repository. This onboarding is not decorative: it is a real foundation for your training experience to be efficient, modular and frictionless. From here, you work as you would in a professional studio: with order, clarity and solid technical direction.

The Unreal Engine Wiki at PlatanoGames is not an annex, it is an active core of technical consultation. It is designed to provide clear explanations, real-world examples and internal links to specific practices and modules. Instead of teaching you out-of-context theory, we show you how to apply each concept within the systems you are already building in the frameworks. For example, if you are developing a damage system, you can look at how components are structured, how the event is propagated, and what class should handle it, in both Blueprints and C++. It's a cross-reference that connects all the pillars of your learning: code, architecture, design patterns and applied best practices.

The Wiki is organized by levels (basic, intermediate, advanced) and by functional areas:

• 📂 Engine fundamentals: execution flow, actors, components, GameMode, GameInstance
• 🔧 Common structural patterns: Singletons, Interfaces, Delegates, Timers, inter-class communication.
• 🧠 Best practices: separation of visual and backend logic, modular design, naming conventions
• 📘 Technical glossary and concept maps with examples in Blueprint and C++

This wiki is intended for all levels, but especially useful for those looking to work professionally in Unreal Engine. If you are just starting out, it will help you not to get lost in technical terms. If you already program in C++ or design complex systems, it will allow you to standardize your way of working and adopt common practices across the entire ecosystem of the academy. It's not just a reference guide, it's a way of thinking technically. In the long run, it becomes your second most important tool, next to the Unreal Engine itself.

You will apply the wiki content in every module, framework and exercise you do. From reviewing a communication pattern to structure a dialog system, to consulting a recommended flow to initialize a `PlayerController` in C++ with access to the `GameInstance`, everything is documented with applied examples. In addition, if you work in parallel with your own personal projects, the wiki allows you to directly integrate the practices of the academy into your pipeline. It is a constant and consistent reference resource, which gives you independence and clarity to work as a real developer, not as a student repeating tutorials.

Version Control is not taught as an isolated theory, but as a key tool integrated from day one. You will learn to work with real repositories on GitHub, organized by frameworks and educational modules, using training branches as if you were part of a professional development team. We show you step by step how to clone projects, synchronize your changes, resolve conflicts, maintain a clean history and apply good versioning practices. In addition, we adapt Git commands and flows to Unreal projects, solving common problems such as `.uproject` files, heavy binaries or conflicts in Blueprints. Here you don't learn Git "just in case", but because it is an essential part of the PlatanoGames technical ecosystem.

The Version Control roadmap is divided into three progressive levels:

• 🔹 **Fundamentals**: what is Git, differences between local and remote, first commits, project cloning.
• 🔹 **Formational flow**: educational branches, management of academy repository updates, synchronization with live templates.
• **Advanced**: conflict resolution, professional merge, cherry-pick, tags by educational versions (v0.1, v0.2, etc.)

Although we start from scratch, the approach is totally professional. You won't just see how to commit, but how to integrate it into your actual workflow as a technical developer in Unreal Engine. If you already use Git, here you will learn how to adapt it specifically to projects with complex folders, heavy content and shared versions of educational frameworks. If you have never used it before, you will learn in a progressive and contextual way, always with real examples. The goal is that it becomes a natural tool for you, not a technical obstacle.

You will apply version control in each module and framework of the academy. From cloning the base framework to upgrading to new versions without losing your custom developments, Git will be the foundation of your workflow. In addition, you will learn how to version your own personal projects, how to collaborate with other students if you wish, and how to keep your content clean, organized and synchronized. This is not an extra, it is an essential professional skill that you will use every step of the way.

Here we don't just teach you how to program: we teach you how to think like a system architect inside Unreal Engine. Programming is worked with a hybrid approach (Blueprint + C++) from the beginning, explaining when to use each language and why. You will learn how to create clean, modular, scalable classes that work both on their own and connected to other systems. Each concept (functions, inheritance, interfaces, delegates, components, managers, etc.) is presented with a direct application in a real system within a framework. In addition, all training follows good professional practices: separation of responsibilities, decoupled communication, conscious use of memory, and design principles such as DRY and SRP. It's much more than learning how to "make it work": you'll learn how to program with production in mind.

This category is structured in three main stages:

• 🔹 **Programming fundamentals** in Blueprint and C++: variables, types, conditional logic, functions, structures and enumerators.
• 🔹 **Modular system design**: components, managers, event systems, interfaces and decoupled flows.
• Advanced architecture**: use of GameInstance, Singleton patterns, flow control and orchestration between subsystems (UI, Gameplay, Networking, etc.).

• 🔧 Logging system decoupled via interfaces
• 🧠 Delegates and Event Dispatchers in C++ with Replication
• 📦 Folder organization and structure by functional modules

This department is designed to offer a complete progression: from fundamentals to real architectural patterns used in professional studios. If you are starting from scratch, we will guide you step-by-step to understand how to design organized systems. If you already have experience, you'll find solid standards, clean refactor, and real-world practice that will save you years of trial and error. Unlike other courses that teach only syntax or single examples, here you will learn how to connect systems, how to structure maintainable code, and how to work in a scalable way, even if your project grows.

You will apply this knowledge in absolutely all academy frameworks. From inventory systems, combat or interaction, to menus, animations and enemy logic, everything is based on a well-programmed structure. For example, in the Shooter Framework you will work with reusable firing and reloading components; in the Technical Simulation Framework, with decoupled sensor and interface logic. You will also be able to apply these practices in your own personal projects, using the structured snippets and templates that accompany each module. It's the core of everything: without good architecture, the rest falls apart. Here you learn how to build with a solid foundation.

At PlatanoGames we teach materials as logical systems, not as loose visual experiments. The Materials and Shading category is structured like the rest of the academy: we start from real needs within a framework (dynamic UI, visual damage, state of materials, special effects, etc.), and develop practical and optimized solutions. Each module is based on functional examples and clear explanations of the internal flow of each node, avoiding blind repetition of patterns. You will see how to organize your graphs by functional layers, how to use instances to modify properties in real time, and how to integrate materials with Gameplay Tags, Blueprints, Niagara or C++. The focus is always on the balance between aesthetics, clarity and performance.

The roadmap is divided into four major progressive blocks:

• 🎨 Unreal Engine material system basics (PBR, nodes, blend modes, shading models)
• 🔧 Creation of practical materials: dynamic surfaces, contextual effects (such as damage, fire, snow, slime, etc.)
• 📦 Instantiation and optimization: master materials, Material Functions, dynamic parameters and correct use of Virtual Textures
• 🧠 System integration: linking with animations, gameplay, particles, post-processing and UI/UX logic

This category starts from scratch, but with a technical and professional approach from the beginning. You will learn from basic visual fundamentals to complex systems with Material Functions, parameterized instances and gameplay oriented materials. If you come from an art background, you will learn to understand the technical impact and optimize your workflow. If you come from programming, you will understand how to visually control game states from materials and how to modulate them to improve visual communication with the player. It's not just about aesthetics: it's about building functional, clean, modifiable and well-integrated materials.

You will apply it in absolutely all academy frameworks. From the visual damage system in the Shooter Framework, to selection shaders in the Simulation Framework, to environment transitions, portal post-processing or visual effects in dynamic HUDs. You will also see how to create material systems that respond to Gameplay Tags or animations, and how to create material presets with reusable functions that you can apply in your own projects. Everything you learn here is intended to be used, extended and optimized in real production contexts.

At PlatanoGames, visual effects are not taught as a decorative add-on, but as an integral part of system design. This category introduces you to the Niagara particle system from the ground up, but with a focus on gameplay, performance and effective visual communication. Every system you build, whether it's a weapon, an ability, an environment or a HUD, is accompanied by functional VFX that communicate states, impacts, timing or player decisions. You will learn to create effects from the basics (emission, collision, color, events) to complex flows such as particles linked to animations, gameplay tags, damage or physics. In addition, you will always work with modular, reusable and real production-oriented logic.

The roadmap for this category is divided into progressive phases that accompany your evolution as a technical effects developer:

• Niagara fundamentals**: modules, emitters, systems, Blueprint control, attributes and collisions.
• 🔹 **VFX connected to gameplay**: shots, explosions, impacts, energy, charge, interaction and player/NPC states.
• 🔹 **Optimization and contextual control**: intelligent culling, level of detail, control from C++, timers and interfaces.
• Advanced integration**: VFX synchronized with animations, sounds, materials, dynamic environment or UI particles.

This category is useful whether you come from art, programming or system design. We start from the most basic concepts and build a solid foundation to create effects that are not only beautiful, but also useful and optimized. If you already know Niagara, you will go deeper into its real integration with C++, Blueprints and game logic. If this is your first contact, you will understand how to control every aspect of a particle and how to visually connect the game state with the player in a professional way. We always work with the idea that effects should have purpose, not just visual impact.

You will apply visual effects in all the main frameworks of the academy. In the Shooter Framework, you will create shooting, blood, reloading, smoke and progressive damage effects. In adventure or simulation projects, you will use them for ambience, environment interactions, UI feedback or portals. You will also learn how to link particles to gameplay events or animations, for example when activating an ability or triggering an environmental reaction. In addition, you will be able to create your own professional presets and particle libraries, ready to be reused and adapted to any type of game.

At PlatanoGames we treat animation as a critical part of the gameplay system, not as a decorative resource. You will learn how to integrate animations into real game flows: controlled from code, synchronized with character states and decoupled for easy reuse. We start with simple animations, then we move on to complete locomotion systems, blending, anim notifies, anim montages, and finally we get to advanced flows such as Gameplay Tags control or contextual animations with dynamic logic. In addition, we teach you how to structure your animation blueprints with clarity: break down motion logic, actions, expressions, and special states into clean, modifiable blocks. If you come from art, you will understand how to animate for gameplay. If you come from programming, you will know how to control and modify animations without relying on the art pipeline.

This category is divided into five functional blocks:

• 🦴 Unreal Animation System Basics: Skeletons, Assets, Blueprints and State Machines
• 📊 Functional animation: base locomotion, synchronization with gameplay, notifies, parameters from C++.
• 🧰 Contextual animations: damage, jump, combat, interaction, dynamic blend and smooth transition between states
• 🔁 Retargeting, IK and montages: creation of anim montages for combos, specific actions and controlled flow from code.
• ⚙️ Professional structure: split animation logic, modular controller design, integration with Input system, Gameplay Tags or UI

This category is suitable for both animation and programming or system design profiles. If you start from scratch, you will learn step by step how animation is structured in Unreal, without getting saturated. If you already have experience, you will focus on how to integrate animations into functional gameplay flows, optimize the use of resources and control the system from events or code. Visual methods as well as C++ and Blueprints approaches are taught, with production-oriented practices, not just prototyping.

You will apply the animation in all frameworks that have characters, NPCs, creatures or entities with states. In the Shooter Framework, you will animate from basic locomotion to shooting, reloading, impact, fall and death. In simulation or adventure projects, you will work with retargeting, blend for emotional states, physical interaction with environment and smooth transitions. You will also create your own modular animation blueprint, which you can reuse and adapt to any new character in your projects. This knowledge is fundamental if you want to create credible, functional and polished experiences.

At PlatanoGames we do not teach AI as an isolated block, but as a system connected to the behavior of the environment, the player and other subsystems. You will learn from scratch to implement AI logic using Behaviour Trees, Blackboards, Perception System and conditional logic, but always applied to real cases and within a complete framework. It is taught in both Blueprints and C++, with clear examples of how to decouple the logic of perception, decisions, animation and reaction, using events, interfaces and delegates. The methodology is based on modular design: each part of the AI can be changed, extended or replaced without breaking the overall system. Here you don't make enemies that just patrol: you build NPCs with states, reactions, communication and functional autonomy.

The roadmap for this category is structured in five phases:

• 🔹 **Fundamentals of AIController, Blackboard and Behaviour Tree**.
• **Perception system (sight, sound, damage, tags)** with modular response logic.
• 🔹 **NPC states** (passive, alert, combat, fleeing, chasing, flanking, etc.)
• **Dynamic decision control** using custom decorators, services, and decoupled external logic (via tags or interfaces).
• 🔹 **Advanced **IA**: response to environmental stimuli, group decisions, short-term memory and contextual behavior.

This category is designed to reach a real professional level in AI creation. If you are just starting out, you will begin with visual logic in Behaviour Trees with simple but functional practices. If you are already experienced, you will go straight to advanced decision patterns, C++ logic for perception and Blackboard manipulation, and multi-agent systems. The difficulty progresses in blocks, but each module is separated by level so you can build from the ground up or specialize without relying on generic content. You don't just teach AI to move: you teach it to think, react and evolve in real context.

You will apply AI in any framework where there are NPCs, enemies, allies, or dynamic entities. In the Shooter Framework you will work with tactical enemies that detect the player, react, attack or flank. In adventure or simulation projects, the AI will be able to detect environments, follow routes, help the player or react to narrative events. The entire system is designed to be decoupled and reusable, so you can apply this AI in your own projects without having to redo logic each time. In addition, you will learn how to structure the code to keep the behavior scalable, testable and easy to debug.

At PlatanoGames we show multiplayer for what it is: a profound change in how you think and structure your game. Here it's not about checking a "replicate variable" checkbox, but about understanding client-server architecture, execution order, authority, latency, and network event synchronization. From the first module you are introduced to the principles of replication with real examples, using Blueprints and C++, and progressively integrate concepts such as RPCs (Remote Procedure Calls), relevance, data compression, and gameplay and UI replication. The focus is on understanding not only what to replicate, but when not to replicate, how to avoid bottlenecks, and how to structure a system that works well both locally and on the network.

The roadmap for this category follows a logical and functional systems-oriented progression:

• 🌐 Fundamentals of the client-server model in Unreal Engine
• 🔁 Replicated variables, RepNotify, relevance, and state optimization.
• 📡 RPCs: Client, Server, Multicast - authority control and validations
• 🎮 Synchronization of input, motion, animations and UI between players
• ⚙️ Integration with systems such as Inventory, Weapons, Menus, and persistent GameInstance
• 🔐 Security, prediction, and strategies to mitigate latency errors.

This category is intended for developers who want to go beyond local projects. If you are starting from scratch, you will begin by understanding what Unreal's network model is and how it affects your design decisions. If you already have experience, here you will learn how to optimize, decouple and structure your systems professionally to support stable, scalable and synchronized multiplayer games. We don't teach generic replication: we teach you how to build real replicable systems within functional projects. Most importantly, you will understand how to debug, test and maintain those systems without falling into common replication cascading mistakes.

You will apply this knowledge in any framework where there is multiplayer interaction, online connection or persistent data synchronization. In the Shooter Framework, you will learn how to replicate shots, weapon states, damage and animations. In cooperative frameworks, you will be able to implement shared logic for inventories, dialogs, environment events or joint progression. You will also learn how to structure your own projects to adapt to PVP, cooperative, matchmaking or even lobbies modes. All training is designed to make what you do in a network robust, scalable and professional from the very beginning.

At PlatanoGames we teach technical design as the art of building functional systems that can be maintained, extended and adapted. Here you don't create "mechanics", but **complete systems**: inventory, damage, life, skills, progression or interaction. Each system is taught with a realistic approach: how is it communicated, who has authority, how is it decoupled, how is it tested, how is it reused? We use both Blueprints and C++, and we always teach design first with clear technical intent: modular, clean and with separation of responsibilities. We start from a case study within a real framework (for example, creating a pickup system that interacts with inventory, UI and sound), and develop from scratch with scalable logic.

The roadmap covers everything from basic systems to complex technical architectures:

• ⚙️ Fundamentals of applied technical design: control logic, inputs, communication and execution flow
• 📦 Creation of functional systems: life, damage, interaction, pickups, gates, player states.
• Advanced structures: control of game states, gameplay tags, timers, cooldowns, managers, and component-oriented architecture.
• 🧠 Full integration: how to connect each system with UI, audio, animation, network and AI logic without creating circular dependencies
• 📊 Refactor, cleaning and maintenance of real code in production

This category is intended for any technical profile - from beginner to intermediate developer - to learn how to design and scale real systems. If you start from scratch, you will first learn how to organize your logic, structure classes and communicate between actors. If you already know how to program, here you will discover how to create reusable systems, with interfaces, events, components, and full flow control. The goal is that you don't depend on external templates or plugins to solve what you can design yourself with a solid foundation. It is the intermediate step between knowing how to "program something that works" and knowing how to "design something that scales".

Everything you learn here is directly applied to the main academy frameworks: combat, exploration, simulation, environmental interaction, progression or crafting. In each of them there is a set of base systems (life, UI, feedback, sound, input, states, etc.) that are built and refactored following exactly this category. Moreover, you will be able to adapt these systems to your own personal or commercial projects, with the certainty that they are well structured, decoupled and ready to grow. There are no loose scripts here: everything you learn is part of a larger structure, designed as a technical designer would do in a real studio.

This category is not intended as a superficial introduction to the editor, but as a technical guide to **understand how Unreal Engine works in depth and how to set it up to work like a pro**. You will learn how to customize the editor, create base templates, set up team projects, prepare cross-platform workflows, and master tools such as the Output Log, Profiler, Message Log, Level Blueprint, and more. Functional explanations are combined with applied practices: configuring LODs, activating debugging systems, extending the editor with C++, and optimizing load times or caches. In addition, all frameworks start with a technical configuration phase of the environment based on this module.

The roadmap for this category is organized in three blocks:

• 🔧 Editor basics: viewport, folders, snapping, browsers, shortcuts, visual tools
• 🧱 Project and environment configuration: GameMode, default maps, essential plugins, render engines and base structure.
• 🚀 Productivity and performance: hot compilation, hot reload, logs, console commands, profiling, caching and debugging

This module is ideal if you are just starting out or if you already work with Unreal but have never really delved into how the engine works. We don't teach menus by rote: we teach the real impact of each configuration. If you're a beginner, you'll understand how to get around efficiently. If you are intermediate or advanced, you will learn to work with the engine as a professional development environment: with structure, cleanliness and real production logic. You will see which errors to avoid, how to debug correctly and how to adapt the engine to your flow, not the other way around.

Everything you learn in this category will be applied in every project, framework or module of the academy. From the initial configuration of each framework to the organization of folders, packaging options, configuration of the input system or preparation of builds. In addition, you will master internal tools of the editor that will allow you to debug AI systems, animations, replication, performance, physics, materials and any other gameplay system. This knowledge is transversal: **without knowing how to work well with the engine, the rest of the code or logic loses strength**. Here you learn how to really work.

At PlatanoGames we understand optimization as a continuous process, not as a final patch. Therefore, this category is taught integrated to the technical design of each framework, focusing on **detecting bottlenecks**, applying real solutions and avoiding structural errors from the beginning. You will learn to work with tools such as the Profiler, the Stat Unit, the GPU Visualizer and the Output Log, interpreting data and making decisions with technical criteria. We also cover the complete pipeline: from importing assets, LODs and nanite, to shaders, collisions, draw calls, instantiation, stream loading and multithreading. This category is not for fixing broken games: it is for **building games that will never break due to bad technical design**.

The roadmap for this category is divided into practical phases, oriented to real problems:

• 📊 Performance analysis: internal engine tools, reading key statistics and diagnosing common problems.
• 🎨 Visual optimization: materials, lights, shadows, textures, post-processing, virtual textures, screen size and culling
• 🧠 Logic and code: tick efficiency, timers, loops, casts, memory, real-time loading and profiling of Blueprint vs C++.
• Production pipeline: asset import, LOD management, channel packing, mesh control, collisions and export flow from DCC (Blender, Maya, etc.).
• 🚀 Preparation for distribution: build sizes, baking, compression, packaging, and analysis of builds for PC, mobile or VR

This category is advanced in its approach, but accessible in its progression. If you are just starting out, you will learn how to spot common mistakes and avoid harmful practices from day one. If you already have experience, here you will find **deep technical strategies**, key metrics, and architecture and performance best practices applicable to commercial projects. Both visual and CPU, GPU, network and code structure issues are addressed, from a comprehensive, professional and real-impact point of view.

You will apply these optimization practices in all academy frameworks. In open levels, you will apply World Partition, HLODs, LOD streaming and Nanite; in UI, you will reduce draw calls and canvas invalidation; in animation, you will adjust updates per frame and relevance. You will also see how to maintain the technical health of your projects over time: clean builds, performance tracking, system testing and best practices to avoid technical debt. In your own projects, this category will allow you to build with confidence, knowing that each system is optimized to scale, not just "work".

At PlatanoGames we teach narrative and cinematics as **functional technical systems** within a real production flow. You will learn to work with Sequencer, timelines, cameras, synchronized animations, dialogues, triggers, events and contextualized logic within the gameplay. It's not just about storytelling, but about **building integrated narrative systems** with player logic, game states and user decisions. In addition, you will learn how to generate reusable cinematics, controlled by Blueprint or C++, and how to integrate them with animations, sound, effects, UI and gameplay. Each resource is developed with a clear purpose: to communicate, excite and connect without breaking the flow of the game.

The roadmap for this category is organized by functional blocks:

• Sequencer basics, cameras and track control (audio, motion, materials, visibility, etc.)
• 🗣️ Interactive dialogs: integration of voice, text, decisions, and synchronization with UI and events
• 🎭 Trigger systems: contextual events, narrative checkpoints, transitions, conditions and narrative logic.
• 📚 Integration with Gameplay Tags, player status and global changes in real time
• 🎞️ Complete pipeline of an interactive cinematic from technical script to playable execution

This category is designed for all types of profiles: if you come from narrative design, you will learn how to implement it; if you come from the technical side, you will learn how to build emotional and interactive logic. If you are just starting out, you will see how to integrate simple systems such as a playable intro, a reactive dialogue or a cinematic with camera. If you already have experience, you will work with reactive sequences, decision branches, global triggers and systemic narrative integrated to complex frameworks. It's not just "making a cinematic": it's building a coherent, functional and connected technical narrative with everything the player does.

You will apply this knowledge in any framework where you want to communicate, guide or reinforce an experience. In adventure or narrative projects, you will be able to build introduction sequences, branching dialogues, dynamic reactions or global events. In shooters, you'll be able to create opening or ending mission cinematics, death cams, briefings, and more. Everything you learn is directly applicable to real production logic: with Gameplay Tags integration, triggers, persistent decisions and adaptability according to the state of the player or the world.

This category focuses on teaching technical art as a functional discipline within the production flow. Here we don't just import a mesh: we teach how to prepare an asset from the DCC (Blender, Maya, etc.), optimize it, **assign functional materials, set up collisions**, pivot points, LODs, UV channels, and how to integrate it correctly in Unreal. Everything is done under technical criteria: not only visual. You will learn how each asset can impact performance, how to work with Nanite, how to use vertex colors, and how to prepare content for modularity, interaction or blending. In addition, good practices for working in a team are taught: nomenclature, versions, folders, and visual documentation.

The roadmap covers everything from the basics to advanced technical flows:

• 🧱 Import and initial configuration of 3D assets (FBX, Skeletal, Static, Sockets, Pivot, LODs)
• 🎨 Integration with functional materials (instances, master materials, logic and visual piping)
• Collision setup, physics, secondary UV channel for illumination, and vertex painting
• ⚙️ Integration with Blueprint, gameplay, modular construction and snapping grid
• 📦 Full workflow from Blender: export, scaling, triangulation, pivoting, skeletons and more

This category is designed for technical artists, integrators or visual programmers who need to master the more structural part of 3D art within Unreal. If you are just starting out, we will guide you on how to prepare assets correctly from modeling to use in the engine. If you already have experience, you will learn how to optimize your pipeline, how to automate tasks, how to keep your scene clean and how to prepare scalable and adaptable assets. Here we work from a real production point of view: it's not enough to look good, it must integrate well, perform well and be organized.

You will apply this knowledge in all frameworks where you work with environments, props, characters or visual interfaces. In the Simulation Framework, you will use these flows to generate modular and functional spaces. In action or adventure games, you will prepare assets with sockets, collisions and dynamic gameplay support. You will also use it in 3D UI, diegetic HUDs, contextual effects and adaptation of commercial assets to your real needs. Everything is oriented so that what goes into the engine is ready for production: no hidden bugs, no bloat, and no friction between art and code.