A structured, project-first track where students blend event-based coding, 2D design, and game design to create and publish complete 2D games.
For students interested in blending coding, 2D design, and game design, we explore GDevelop5—a powerful no-code game engine using event-based programming (a bridge between block coding and traditional scripting). Students progress from guided game building to independent game creation: mastering the GDevelop toolset, building code solutions for game features, and publishing complete 2D games. The program combines creative game design with logical programming thinking.
Students modify an existing platform game to build familiarity with GDevelop fundamentals. They learn to identify events (conditions + actions), create and modify objects, and understand how event-based logic drives game behavior. Students gain comfort navigating the GDevelop interface and basic toolsets.
Students create their first game from scratch: an endless runner. They learn to use the Piskel editor for sprite creation, set up foundational game elements, apply behaviors to objects, and create animations. Students understand how visual assets and code logic work together to create gameplay.
Students build their second game, focusing on game design planning and identifying essential platformer systems. They learn to break down complex games into core components, use camera actions for following players, and create custom behaviors. Students practice iterative design: plan, build, test, improve.
Students create NPCs with specific characteristics and interactive behaviors. They implement custom behaviors triggered by player clicks, measure distance between objects for proximity detection, and use collisions for game interactions. Students learn how event logic creates responsive, dynamic game characters.
Students explore inventory systems in games and implement their own. They learn about arrays vs variables, understanding when each data structure is appropriate. Students create pickup systems allowing characters to collect and store items, learning fundamental programming concepts through practical game mechanics.
Students learn to create and manage scene variables and object variables. They implement variables through both code and manual creation, read and modify variable values through events, and understand how variables track game state (scores, health, progress). Students see how data drives game logic.
Students reflect on previous projects and plan improvements. They assess game quality, identify areas for enhancement, and add features that improve player experience. Students practice critical evaluation: what works, what doesn't, and why. Focus is on iterative improvement and design thinking.
Students finalize projects, present their work to classmates, and provide constructive feedback on others' games. They demonstrate gameplay, explain features implemented, share design choices, and discuss challenges overcome. Students practice professional presentation skills and learn from peer feedback.
Students examine how event-based coding aligns with traditional programming. They understand event structure (conditions → actions), learn to create events independently, and see how GDevelop's visual system translates to programming logic. Students implement specific event-code features to build game mechanics.
Students learn to create object groups and use for-each events to apply actions to entire groups efficiently. They understand iteration in programming, create object classes, and implement logic that affects multiple game objects simultaneously. Students see how loops reduce repetitive code.
Students create events using while loop conditions for continuous checking and updating. They implement game logic that runs repeatedly until conditions change, understanding conditional loops and their applications in game systems. Students practice writing efficient loop-based event logic.
Students create linked events—reusable event blocks shared across multiple scenes. They learn code reusability principles, understand how to reference existing logic rather than recreating it, and organize events efficiently. Students see how modular code design saves time and reduces errors.
Students create custom functions: reusable condition-action sets they can call throughout their games. They learn function parameters, understand when to create functions vs inline events, and see how functions organize complex logic into manageable pieces. Students practice modular programming thinking.
Students plan game features using all learned event systems. They complete a plan-of-work identifying required tools, event types needed, and implementation steps. Students practice scoping projects realistically, breaking complex features into achievable tasks, and estimating development time.
Students develop their planned game with instructor support. They implement features using advanced event logic, debug issues, test mechanics, and refine gameplay. Focus is on applying all learned event systems to create a complete, polished game with working advanced features.
Students present completed games and explain their event systems. They demonstrate how features work, walk through key events, explain logic choices, and discuss technical problems solved. Students practice communicating technical concepts clearly and receive feedback on both game design and code architecture.
Students design a custom game from scratch or continue a previous project. They create a comprehensive project plan meeting specific criteria, identify required tools and event systems, propose game features and code solutions, and justify their design choices. Students define realistic scope considering time and skill constraints.
Students begin building their custom game, establishing core mechanics and foundational event systems. They break features into specific tasks, implement basic gameplay, and test core loops. Focus is on building strong foundations: clear event organization, tested core mechanics, and stable base systems before adding complexity.
Students expand their games with additional features and begin integrating multiple systems. They test feature interactions, debug integration issues, and refine game balance. Students apply learned workflows: iterative development, systematic testing, and incremental improvements rather than adding everything at once.
Students add advanced features and polish: visual effects, UI improvements, complex event logic, and player progression systems. They focus on feature completion over feature quantity, ensuring each mechanic works properly and enhances gameplay. Students practice time management and feature prioritization.
Students perform comprehensive playtesting and quality assurance. They identify bugs, fix event logic errors, optimize performance, and improve user experience based on testing. Students refine game balance, adjust difficulty curves, enhance visual consistency, and prepare games for public sharing.
Students complete final implementation tasks, addressing remaining bugs and adding final polish. They optimize event systems for better performance, improve visual presentation, ensure all features work correctly, and prepare showcase materials including game descriptions and presentation notes.
Students share projects with classmates and receive structured feedback. They playtest each other's games, provide constructive criticism on game design and event logic implementation, and suggest improvements. Students practice professional feedback: giving specific, actionable suggestions and receiving criticism gracefully.
Students present final games to classmates, instructors, and invited guests. They reflect on their development process: features implemented, event systems created, challenges overcome, and lessons learned. Students demonstrate mastery of GDevelop, event-based programming, game design principles, and independent project management.
Side-scrolling platformers with jumping mechanics, obstacles, power-ups, and level progression.
Fast-paced games with procedural obstacles, scoring systems, and increasing difficulty.
Logic-based games featuring inventory systems, object interactions, and problem-solving mechanics.
Exploration games with NPC interactions, custom behaviors, and narrative elements.
Action games with collision detection, score tracking, lives/health systems, and win/lose conditions.
Original game concept designed and built independently, combining all learned systems into a polished project.
This program is designed to build logical thinking, creative design skills, and visible progress. Students learn programming concepts without the complexity of syntax, making it perfect for younger students or those new to coding.
Students learn programming logic (conditions, loops, variables, functions) without typing code, removing syntax barriers.
Students develop both creative game design skills and structured programming thinking through event-based logic.
Games export to web, mobile, and desktop platforms, giving students real-world publishing experience.
Event-based programming builds logical thinking that transfers directly to JavaScript, Python, and other languages.
Students master visual programming through events, conditions, and actions—learning core programming concepts without syntax complexity.
Students learn to break complex problems into sequences of events and actions, developing systematic problem-solving skills.
Students create sprites, animations, and visual assets using Piskel, understanding how art and code combine to create games.
Students design game mechanics, balance difficulty, create player feedback loops, and iterate based on playtesting.
Students work with variables, arrays, and object properties, learning when to use each data type for game state management.
Students create functions, linked events, and reusable logic blocks, learning modular programming principles.
Students plan, build, test, and publish complete games with minimal guidance, demonstrating technical independence.
Using condition → action logic to create game behavior without typing code syntax.
Creating sprites, animations, backgrounds, and visual assets using Piskel and art tools.
Breaking complex problems into sequences of events, conditions, loops, and functions.
Implementing platformer controls, gravity, movement behaviors, and collision detection.
Creating score systems, health mechanics, level progression, and win/lose conditions.
Exporting finished games to web, mobile (Android/iOS), and desktop (Windows/Mac/Linux).
No prior coding experience required. GDevelop uses visual event-based programming—students learn programming concepts without typing code, making it perfect for beginners.
While Scratch uses block coding, GDevelop uses event-based logic (condition → action), which is closer to real programming structure. GDevelop games also export to real platforms (web, mobile, desktop) not just online sharing.
Yes. Event-based programming teaches core concepts (variables, conditions, loops, functions) that directly transfer to JavaScript, Python, and other languages—without overwhelming students with syntax.
Each level builds on previous skills. We recommend starting at Level 1 unless your child has completed similar event-based programming courses and can demonstrate proficiency with GDevelop.
Students export playable games you can run on your computer, phone, or browser. You'll receive exported game files and can watch them present projects during showcase sessions.
Questions about enrollment or want to discuss your child's learning path?
Phone/WhatsApp/Zalo: 0902 776 753
Email: hello@techtutor.academy
Website: techtutor.academy
Hours: Mon-Fri 8:00-21:00 | Sat-Sun 8:00-20:00