First Look at Godot Engine
- https://www.youtube.com/watch?v=6CHkSG9NWoc
- Original title: I tried Godot and instantly became a Rich Indie Dev
Tsoding opens the Godot engine for the very first time and, live and unscripted, fumbles his way toward a tiny 2D game. Coming from a Java enterprise background and normally writing games from scratch in C with Raylib, he has never touched a classical game engine before. Over roughly two hours he downloads Godot, pokes at its editor, and by trial and error builds a "Hatman" sprite that walks, flips direction, and switches between walking and idle animations via WASD input in GDScript. The clickbait title is ironic: he never gets rich and never even finishes the Pong game he set out to make, but he does form a surprisingly positive impression of the engine while grumbling at its quirks.
The session doubles as a genuine usability review of Godot from the perspective of a competent programmer with zero engine experience, and ends with a brief tour of Godot's own C++ source code.
Summary
First impressions and setup. Tsoding stresses he is not a game developer and has only ever used Raylib, a plain library rather than an engine — his own unnamed game is software-rendered on the CPU at low resolution and still hits ~140 FPS. He downloads the native Linux build and is delighted to find it ships as a single self-contained AppImage executable that just runs with no dependency hell, riffing at length about how rare "nice things" are in 2026.
Getting oriented. He creates a new project (choosing to make Pong, and picking the Forward+ renderer and Git version control), then explores the editor. Blender middle-mouse shortcuts work, which he appreciates. He works out that a Godot game is a tree of nodes whose `_process` and other underscore-prefixed virtual callbacks run each frame, and that scripts are GDScript — "Python plus C#" — with static typing and type inference. He is amused that even things like HTTPRequest are nodes you could drop into a scene.
The animated-sprite struggle. His biggest friction point: he grabs a free four-frame "Hatman" walk animation from OpenGameArt and cannot figure out how to feed the individual PNGs into an AnimatedSprite2D. The interface refuses his files and he rants that the engine won't "just take my files." He falls back to a plain Sprite2D (which trivially accepts one texture), gets it on screen, adds a Camera2D, and moves on. Only much later, guided by a tutorial and chat, does he discover the SpriteFrames panel that pops up at the bottom of the editor — he genuinely never noticed it appear.
Movement and input. He attaches a script to the sprite and makes it move by adding `velocity * delta * speed` to `position` in `_process`. He wires up WASD via the `_input` callback, initially reacting to any key, then refines it: a `directions` dictionary maps key names to `Vector2` offsets, accumulating and subtracting velocity on press/release. He fixes a repeated-key bug by checking `event.is_echo()`, and flips the sprite horizontally by setting `flip_h` based on the sign of `velocity.x`, preserving the last-faced direction when standing still.
Animations and scenes. He adds a second "standing" animation (hand-drawing frames in LibreSprite, since he can't buy Aseprite binaries from Russia), then switches between `walking` and `standing` based on whether velocity is zero, adding a bouncy two-frame idle. Reading the docs, he realizes he has been "using Godot incorrectly": much of the logic he hand-coded already exists as dedicated nodes (e.g. CharacterBody2D), and scenes are reusable, instantiable trees of nodes — essentially composable custom node types.
Verdict and source-code tour. His overall take: Godot is a strict, opinionated framework that gives you one blessed way of doing things and feels a lot like a web framework — the happy path is a few clicks, but deviating means writing plenty of code anyway. He calls it self-explorable and workable, and could see using it commercially "if paid a lot," but for his own recreational programming he'd still rather code everything himself. He closes by cloning Godot's repository (C++, built with the SCons Python-based build system, which prompts a rant about C++ devs reaching for Python), and finds the code clean and easy to navigate — locating the `AnimatedSprite2D` C++ class and confirming the internal `h_flip` field is bound to GDScript's `flip_h`, which he cites as why the project attracts so many contributors.