python_rob

A lightweight Python framework for building simple, interactive 3D robotics simulations — built on Ursina (and Panda3D underneath it), with no external simulator installs, licenses, or Linux-only toolchains required.

Why this exists

Robotics courses love to teach path planning, obstacle avoidance, distance/margin calculations, and crowd control — but the moment students want to see it, they hit a wall. Most serious robotics simulators (Gazebo, Webots, CoppeliaSim, ROS-based stacks, etc.) are heavy, awkward to install, and often flat-out painful on Windows, which is what the majority of students actually have on their laptops.

The idea behind this project is to lower that barrier to near zero:

• Pure Python, pip-installable dependencies — no ROS, no external simulator binaries, no Docker.
• Windows-friendly — Ursina/Panda3D run natively and reliably on Windows, unlike most robotics sim stacks.
• Minimal mental overhead — spin up a plane, drop in some obstacles, and place a "robot" cube in a few lines of code.
• Good enough for the concepts that matter — this isn't trying to replace physically-accurate simulators. It's meant for teaching/experimenting with the algorithms (path planning, obstacle avoidance, distance calculations, margin/crowd control) without fighting the tooling.

In short: an approachable sandbox so robotics students can prototype and visualize ideas quickly, instead of spending the first week of the semester just trying to get a simulator to launch.

What it currently does

The project is still very early-stage. Right now it provides two small building blocks:

• Environment (Environment.py) — sets up the 3D scene:
  • Creates a ground plane (create_plane) with configurable scale, position, and color.
  • Creates simple box/cube obstacles (create_obstacle) at given positions and scales.
  • Handles axis-convention mapping (coords_mapper) so you can think in a more intuitive (x, y, z) with y as height, regardless of Ursina/Panda3D's internal axis order.
  • Can draw a visual XYZ axis gizmo (show_axis) for orientation while prototyping.
  • show_fps() helper to toggle an on-screen FPS counter.
• Robot (Robot.py) — a minimal entry point for instantiating a robot as a colored cube (or other shape), with configurable color, scale, position, and collider. This is meant to represent a robot in the scene for simple experiments (it does not yet do anything on its own — see Roadmap).
• Instantiating_test.py — a working example/demo script that builds a small scene: a ground plane plus five obstacles of varying size, color, and position, with an orbiting EditorCamera so you can fly around and inspect the layout.

At this point, the project is essentially a scene-building utility layer — it doesn't yet simulate robot behavior, movement, sensing, or planning algorithms.

Status

Under active early development. APIs, class structure, and naming are all subject to change. Treat this as a prototype/proof-of-concept rather than a stable library.

Roadmap / future goals

• Give Robot actual behavior: movement, rotation, and simple kinematics (not just a static placed cube).
• Path planning primitives (e.g. A*, RRT) with visual playback of the computed path.
• Obstacle avoidance and margin/safety-distance calculations, visualized in real time.
• Simple sensor models (e.g. raycast-based distance sensors) attached to a Robot.
• Multi-robot / crowd-control scenarios.
• A cleaner, more declarative API for building scenes (less manual Vec3 juggling).
• Example notebooks/scripts aimed specifically at classroom exercises.
• Packaging it up (pip install-able) so it's trivial for a student to get started on Windows, macOS, or Linux.

Getting started

pip install ursina colorama panda3d
python Instantiating_test.py

This launches a window with a ground plane, a handful of obstacles, an axis gizmo, and a free-flying editor camera you can use to look around the scene.