Ludo.ai

AI Game Development Tutorial Generator

Ludo creates a custom, interactive development tutorial based on your game concept, designed to help you go from idea to a playable game.

Ludo's Tutorial Generation, the Tutorial tab of a project, shown from its setup to a real generated guide:

  1. Customize: In a project's Tutorial tab, choose an experience level (Beginner or Advanced), a game engine (Unity, Cocos2d-x, Buildbox, Solar2D, Godot, Unreal or Roblox) and, optionally, what the guide should focus on. Beginner and Unity, the defaults, with no prompt: a complete development guide, from initial setup to final optimization.
  2. Your guide: Ludo reads the project's design document and writes a guide for that game in the chosen engine: categories, topics and numbered steps, each opening into instructions with code and a chat with Ludo for questions. The Unity guide for the project Cardboard Clash opens on Initial Setup & Project Foundation: installing Unity Hub and the Unity Editor (LTS), creating a new 2.5D project for Cardboard Clash, organizing its folders and creating the main game scene.

What is AI Tutorial Generation?

AI tutorial generation turns your game design document into a personalized, step-by-step development guide for the engine you choose. Ludo reads your project's mechanics, features, and assets, then writes an ordered roadmap of topics and steps, with explanations and code snippets tuned to your experience level, so you can build your specific game from initial setup through to final optimization.

Last updated November 2026

How it works

  1. Finalize Your ProjectComplete your game's design in the Edit tab of your Project so Ludo has the mechanics, features, and assets to build the guide from.
  2. Generate Your GuideOpen the Tutorial tab, choose your experience level (Beginner or Advanced) and target engine, add an optional prompt to steer the focus, and generate. Leave the prompt empty for a complete development guide.
  3. Build Step by StepWork through the generated topics and steps with their code snippets, and ask the built-in Ludo Assistant for help with implementation, troubleshooting, or best practices on any step. Guides are saved, so you can come back or create another one.
Get a guide for your gamePick your level and engine and get a step-by-step guide written for your project. Free to start, no card needed.

Three choices, then Generate Guide

    • BeginnerNew to game development. Learn core concepts and basic implementations.
      • Detailed explanations of basic concepts
      • Step-by-step guidance
      • More code comments and examples
      • Focus on fundamental patterns
    • AdvancedExperienced developer seeking advanced techniques and optimizations.
      • Advanced optimization strategies
      • Complex system architectures
      • Edge cases and performance tuning
      • Platform-specific considerations

    Beginner or Advanced

    Beginner explains the concepts and comments the code. Advanced goes to architecture, optimization and edge cases.

    • Cocos2d-x
    • Buildbox
    • Solar2D
    • Unreal
    • Roblox
    BeginnerOne-Thumb Steering Script
    GDScriptextends Area2D # The horizontal position we want Pip to reachvar target_x: float = 0.0 func _process(delta):    position.x = lerp(position.x, target_x, lerp_weight)
    AdvancedSpline Path Controller
    C#public struct SplinePoint{    public Vector3 Position;    public Vector3 Tangent;    public Vector3 Normal;    public float DistanceFromStart;}

    Written for your engine

    Pick one of seven engines and the guide uses its nodes, APIs and language. Ripple Run came back in GDScript for Godot and in C# for Unity.

    • Unity
    • Godot
    • Unreal
    • Roblox
    • Cocos2d-x
    • Buildbox
    • Solar2D
  • Customize Your Guide (Optional)Leave empty for a complete development guide.Examples
    • Focus on creating dynamic enemy AI that adapts to player behavior, using advanced techniques like behavior trees and state machines
    • Walk me through designing immersive, procedurally generated levels
    • Help me build a narrative-driven game by integrating intricate quest systems, rich character development, and interactive dialogue mechanics.
    Generate Guide

    An optional focus

    Say what the guide should concentrate on, such as enemy AI or procedural levels, or leave the box empty for a complete guide from setup to export.

A guide written for your game

  • Interactive Development Guide for Ripple RunExperience Level: NoviceEngine: Godot
    1. Project Foundation
      1. 1Engine Installation and Project Creation
      2. 2Display and Input Mapping
      3. 3Folder Organization
    2. Core Player Mechanics
      1. 4Player Scene Setup
      2. 5One-Thumb Steering Script
      3. 6Passenger Visuals
    3. The Moving River
      1. 7Scrolling Water Background
      2. 8Hazard Spawning Foundation
      3. 9Obstacle Spawner Logic
      4. 10Dynamic Speed Progression
    4. Gameplay Systems
      1. 11Berry Item Scene
      2. 12Golden Berry Transformation
      3. 13Score Manager
      4. 14Silas Character Setup
      5. 15Beak Javelin Attack
    5. User Interface and Polish
      1. 16Heads-Up Display (HUD)
      2. 17Health and Collision Logic
      3. 18Main Menu and Restart
      4. 19Atmospheric Lighting
      5. 20Sound Effects and Music
      6. 21Mobile Export and Optimization

    The whole build, in order

    Ludo reads the design document and lays out sections, topics and numbered steps. Ripple Run in Godot is 21 steps, from installing the engine to the heron boss from its Enemies section and the mobile export.

    • Sections
    • Topics
    • Numbered steps
    Project
  • The Raft ControllerStep 2: One-Thumb Steering Script

    In Ripple Run, the steering mechanics are the heartbeat of the player's experience. While the river moves vertically, the player's agency is strictly horizontal.

    Implementation Strategy: Horizontal Smoothing

    The raft will seek the horizontal position of the touch input, but its movement will be governed by a weight factor. This creates a natural-feeling lag, similar to water resistance.

    GDScript# How quickly the raft catches up to the input (0.0 to 1.0)@export var lerp_weight: float = 0.15 func _input(event):    if event is InputEventScreenTouch or event is InputEventScreenDrag:        target_x = clamp(event.position.x, margin, screen_width - margin)

    Each step explains, then shows the code

    Open a step for why it matters in your game, how to do it in the engine, and the script to paste, with testing and troubleshooting notes.

    • Previous Step
    • Next Step
  • Have questions about One-Thumb Steering Script?How do I make the raft drift back to the middle of the river when the player lets go?To make the raft gently drift back toward the center when the player releases their thumb, you can detect when the touch release occurs and reset target_x to the center of the screen.Updated Player.gd
    GDScript# Player lifted their thumb: let the current pull Pip back to centeris_touching = falsetarget_x = center_x

    A chat on every step

    Stuck, or want it different? Ask at the bottom of the step. The assistant knows the step and the game, and answers with updated code.

    Ask Ludo

Follow it into a running game

  • Steps 1 to 10, running in Godot

    We followed the Ripple Run guide in Godot 4, pasting each step's script as written. Ten steps in, Pip steers the raft down a scrolling river past spawning logs.

  • Your Development Guides
    • ExpertUnityCreated: 11/2/2026
    • NoviceGodotCreated: 11/2/2026
    • Create a new guide

    Several guides per project

    Guides are saved with the project. Make another for a different engine, level or focus, and switch between them from All Guides.

    • New Guide
    • All Guides
Video

Watch a design document become a Godot guide with code

The Tutorial tab turns the Ripple Run design document into a 21-step Godot guide written for that game, from the raft controller to the boss, with code in every step, and an Advanced guide in Unity. Tutorial generation starts at 2:52.

Questions, answered

The short answers. For the full detail on every mode and setting, see the documentation below.

  • It generates a unique, step-by-step development guide tailored to your game project. Ludo reads your Game Design Document and produces a personalized roadmap, organized into topics and steps with instructions and code snippets, for the game engine you select, from initial setup through to final optimization.

  • In the Tutorial tab of your Project, next to the Edit tab where you write the design document.

  • You can generate a guide for Unity, Godot, Unreal, Roblox, Cocos2d-x, Buildbox, and Solar2D. The guide is tailored to your chosen engine's specific APIs and code conventions.

  • The guide is built from your Project. Ludo reads the mechanics, features, and assets described in your Game Design Document and writes a roadmap specific to that game, rather than a generic engine tutorial.

  • Yes. Select Beginner for detailed explanations of core concepts, step-by-step guidance, and more code comments and examples, or Advanced for complex system architectures, optimization strategies, edge cases, and platform-specific considerations.

  • Yes. Steps that need code include it alongside the written instructions, tailored to the APIs and patterns of the engine you selected, so you can follow along and build directly in your project.

  • Every step has an integrated chat with the Ludo Assistant. You can ask it for clarifications, code explanations, troubleshooting help, or best practices specific to the step you are working on, without leaving the guide.

  • Yes. You can add an optional prompt to steer what the guide focuses on, regenerate content with different settings, and keep multiple saved development guides for a project so you can revisit or compare different approaches.

  • No. Tutorial generation is an in-app feature inside the Project tool. Ludo's API, MCP and CLI cover asset generation (images, sprites, animation, 3D models, video, and audio) rather than development guides.

Tutorial Generation documentation

Introduction

Tutorial Generation turns your game design into a step-by-step development guide. It reads your Project (the mechanics, features and assets described in its Edit tab) and writes a guide for building that specific game in the engine you choose, from setting up the engine to the last features.

With Tutorial Generation you can:

  • Get a guide written for your game, not a generic engine tutorial.
  • Pick one of seven engines: Unity, Cocos2d-x, Buildbox, Solar2D, Godot, Unreal or Roblox. The guide uses that engine's tools, APIs and language.
  • Choose Beginner or Advanced, to set how much the guide explains.
  • Steer it with an optional prompt, such as enemy AI or procedural levels, or leave it empty for the complete build.
  • Follow numbered steps, each with instructions and code, and ask Ludo about any step in a chat right inside it.
  • Keep several guides per project, for different engines, levels or focuses.

Tutorial Generation lives in the Tutorial tab of a Project. It is part of the web app: the API, MCP server and CLI make assets, not development guides.

Start Building Your Game Today
Get a custom roadmap from concept to creation. Sign up to generate a personalized development guide for your specific game idea and engine.