I decided to jump right into Godot’s basics, just to see how nodes and scenes come together before touching any GDScript. Here’s a quick rundown of what I discovered and how the engine’s structure feels when you’re starting out.
Diving into a Blank 2D Scene
I opened Godot, chose a new 2D scene, and was instantly greeted by a single “Node2D” in the Scene panel. It felt strange at first—just one node sitting there with no graphics or functionality. But as I hovered over it, I saw the Inspector window light up with all the properties a “Node2D” can inherit (position, rotation, scale, etc.). It’s clear Godot treats everything as a node, so even that empty Node2D is already part of a larger hierarchy.
When I hit “Play the project (F5)”, Godot reminded me that I didn’t define a main scene yet.
It made sense—nothing is saved, and nothing is marked as the entry point. So I went ahead and saved my scene as Level_1.tscn. Suddenly, the engine could run it, even if it was just a blank canvas window.
Adding a Sprite & Seeing That Node Structure in Action
Since the scene was admittedly boring, I dragged the icon.svg that godot automatically generated when I created the project, into my viewport. Almost instantly, Godot inserted it as a child node. I watched the scene tree grow.I hovered over the Icon in the scene tree and saw the Type is aSprite2D node.
Because there was no texture yet, the sprite wasn’t visible on screen. I saved the the scene and hit “Play” again, the window popped up, but my Icon sat just off-frame—another reminder that positioning matters, and that viewport size can hide newly placed nodes.
Going back to the editor, I clicked on Icon and saw all its “canvas item” properties in the Inspector (texture, region, modulate, etc.). It became obvious that nodes aren’t just boxes to tick off—they carry specific functionality. In this case, the (Icon)Sprite2D is a canvas item capable of rendering an image.
A Glimpse at Inheritance & Node Hierarchy
One “aha” moment was seeing how Node2D and Sprite2D share properties through inheritance. For example, Node2D has transform properties (position, rotation, scale), and Sprite2D inherits those while adding its own texture-specific settings. Even though I’m not writing code yet, I could feel how each node type extends the one above it.
The Sprite2D texture is the icon.svg, but I could already imagine swapping in different textures or adding collision nodes for interactivity. Essentially, Godot’s “everything is a node” philosophy lets me layer functionality—rendering, physics, audio, scripting—by simply plugging the right node into my scene tree.
What I Learned (and What Comes Next)
- Nodes Are Everything: From the blank Node2D to that first Sprite2D, every game element in Godot is just a specialized node in a larger tree.
- Scenes Are Organized Trees: Grouping child nodes under a root node keeps your project tidy. I instantly saw how that structure will scale once more children (animations, collisions, audio) come into play.
- Saving & Running Requires a “Main”: Until you save and designate a scene, Godot won’t know what to launch. That was a helpful little nudge.
- Viewport & Positioning Matter: My sprite showed up off-screen at first, so I got a taste of how important it is to keep an eye on coordinates and the camera or window size.
- Inheritance Behind the Scenes: Even without writing a line of GDScript, understanding that Sprite2D inherits from Node2D (and CanvasItem) made the engine’s logic click.
This quick tour of nodes, scenes, and the basic runtime flow has me excited to start diving into actual scripting. Now that I’ve seen how the pieces slot together, I feel ready to explore GDScript and begin bringing these nodes to life with code. Stay tuned for the next post, where I’ll take that first step into attaching scripts and writing logic in Godot!
