Python Ursina 3D Engine — Core Concepts

What Ursina Is

Ursina is a Python game engine built on top of Panda3D, one of the most battle-tested open-source 3D engines available. Where Panda3D exposes a large, sometimes verbose API, Ursina wraps it in a layer that feels natural to Python developers. The result is an engine where creating a textured, lit 3D scene takes remarkably little code.

Entities — The Core Building Block

Almost everything in Ursina is an Entity. An entity is a thing in your 3D world — a cube, a sphere, a loaded 3D model, or even an invisible trigger zone. You configure it through keyword arguments:

Entity(model='cube', color=color.red, position=(0, 2, 0), scale=2)

Entities have properties for position, rotation, scale, color, texture, collision, and parent-child relationships. Changing any property instantly updates the rendered scene.

Built-In Primitives and Models

Ursina ships with common shapes — cube, sphere, quad, circle, cylinder, cone, and more. For custom visuals, you load .obj, .gltf, or .blend files. Textures can be image files or procedurally generated.

A hierarchy system lets you attach entities to each other. Rotate a parent entity and all children rotate with it, just like moving a box with smaller boxes glued on top.

The Game Loop

Ursina runs a loop behind the scenes. Each frame, it calls the update() function you define at the module level (or as a method on entities). Inside update, you move objects, check conditions, and advance game logic. The engine provides time.dt — the seconds since the last frame — so your movement stays smooth regardless of frame rate.

Input Handling

Keyboard and mouse events are handled through simple functions:

• input(key) — called once when a key is pressed or released.
• held_keys — a dictionary you check inside update for continuous actions like walking.
• Mouse — mouse.position gives screen coordinates; raycasting (mouse.hovered_entity) tells you which 3D object the cursor is pointing at.

First-Person Controller

One of Ursina’s most popular features is the ready-made FirstPersonController. Drop it into your scene and you immediately have WASD movement, mouse-look, gravity, and jumping. Building a Minecraft-style exploration prototype takes minutes instead of hours.

Collision and Raycasting

Entities can be given colliders (box, sphere, mesh). Ursina checks for intersections each frame, and you can respond with callbacks. For line-of-sight checks, raycast() shoots an invisible line into the world and reports what it hits, its distance, and the hit normal.

UI and Text

Ursina treats UI elements — buttons, text, sliders, health bars — as entities positioned in screen space rather than world space. This keeps the API consistent: you style a button the same way you style a 3D cube.

Common Misconception

“Ursina is a toy engine that can’t handle real games.” While it is optimized for rapid prototyping and learning, several indie games and game-jam entries have shipped with Ursina. Its Panda3D foundation provides real shader support, scene-graph optimization, and multi-platform builds.

The one thing to remember: Ursina wraps the power of Panda3D in a beginner-friendly Python API — entities, input, and a first-person controller out of the box.