SimWorld Embodied Agent Simulator
Develop and evaluate multimodal autonomous agents in realistic physical and social worlds.
- Source repo
- SimWorld-AI/SimWorld
- Stars
- ★ 787
- Last updated
- 3mo ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 42/100 · Major gaps
At a glance
- How it runs
- Works with
- Portable with changesOpenAI API (Partial support)
- Cost
- Free software; you pay for model usage
- Setup effort
- High · needs real infrastructure
- You'll need
- Typical use
- Embodied-AI researchers evaluating VLM navigation, planning, or object interaction in physically simulated urban and indoor scenes.
- Not a fit if
- Developers without a dedicated GPU or 50-200GB of disk space
- Users wanting a single-command run without launching a separate UE server
- Source review
- 42/100 · Major gaps 5 safety controls not found
What does this agent do, and when should you use it?
SimWorld is an Unreal Engine 5 simulation platform for developing and evaluating LLM/VLM agents in complex physical and social environments. Its three-layer architecture combines an Unreal Engine backend, an environment layer for city and traffic generation, and an agent layer that reasons over multimodal observations and executes planned actions. The Python package includes Communicator, Humanoid, Map, BaseLLM, a local action planner, city generation, traffic, weather, and asset-retrieval components. Agents can consume position, orientation, RGB, depth, or segmentation observations and interact through movement, rotation, pickup, sitting, and other documented action types. Deployment spans a local Python client and a separately launched UE server; the required Base package supplies two lightweight city maps and one empty map, with more than 100 optional prebuilt maps.
A typical run connects to an active Unreal Engine server with Communicator(UnrealCV()), constructs a Humanoid, and places it in the world through communicator.spawn_agent. The environment reads position and orientation through UnrealCV and obtains visual input with communicator.get_camera_observation, producing observations such as position, direction, and an egocentric image. In the navigation example, BaseLLM("gpt-4o") turns the observation and target into a textual action; the environment parses that action and invokes communicator.humanoid_step_forward or communicator.humanoid_rotate. Other APIs can place objects with communicator.spawn_object, procedurally build a city with communicator.generate_world, and remove environment objects with communicator.clear_env. YAML configuration controls the seed, time step, UE blueprint paths, city generation, traffic, asset retrieval, and agent/model options; a task loop can return updated multimodal observations, a distance-based reward, and success state.
- Embodied-AI researchers evaluating VLM navigation, planning, or object interaction in physically simulated urban and indoor scenes.
- Robotics teams testing pedestrian, vehicle, or robot behavior in UE environments before deciding whether to run physical trials.
- Multi-agent researchers constructing traffic and social scenarios for cooperation, strategic reasoning, and behavior evaluation.
- Simulation and data engineers collecting structured RGB, depth, and segmentation observations for training or benchmark experiments.
- Unreal Engine developers bringing existing maps, assets, or character models into a Python-controlled simulator through custom
.pakfiles. - Teaching and prototyping teams demonstrating autonomous navigation with the Base maps and a Gym-like
reset/steploop.
How do you install or deploy this agent?
The documented requirements are Windows or Linux, Python 3.10 or later, a dedicated GPU with at least 6GB VRAM, 32GB RAM, and 50–200GB of disk space depending on the package.
Install the Python client:
git clone https://github.com/SimWorld-AI/SimWorld.git
cd SimWorld
conda create -n simworld python=3.10
conda activate simworld
pip install -e .Download and extract the Base UE server package for the operating system. Base is required and includes two city maps plus one empty map. Optional environments are distributed as separate .pak files and should be copied into SimWorld/Content/Paks/ under the Base server directory. For custom settings, run cp config/example.yaml config/your_config.yaml, fill in the local paths, and load it with Config('path/to/your_config') using an absolute path. The example constructs BaseLLM("gpt-4o"), but the supplied material does not document the required API credential variable, configuration key, or credential-acquisition procedure.
How do you use this agent?
Start the UE server before running Python code. On Windows, double-click SimWorld.exe or run ./SimWorld.exe <MAP_PATH>; on Linux, run ./SimWorld.sh <MAP_PATH>. <MAP_PATH> is an Unreal Engine internal map path such as /Game/hospital/map/demo.umap. If it is omitted, the server opens /Game/Maps/demo_1.
With the server running, execute an example under examples/ or open examples/gym_interface_demo.ipynb. A minimal loop creates Communicator(UnrealCV()), calls communicator.spawn_agent from reset() to place a Humanoid, and reads position, orientation, and camera output. It then repeatedly asks the agent for an action and passes it to step(action), which invokes movement or rotation APIs and returns the next observation and reward. Separate examples cover city layout generation, traffic simulation, asset retrieval, cameras, and direct UE commands. Custom maps, objects, and agent models must first be packaged as .pak files and installed in the server's Paks directory.
What are this agent's strengths and limitations?
- The UE5 backend combines realistic rendering and physics with procedural cities, traffic simulation, and agent control in one architecture.
- Observation support includes position, orientation, RGB, depth, and segmentation, while the action space covers pedestrians, vehicles, and robots.
- The small Base package supports initial testing, while more than 100 separately packaged
.pakmaps can be installed selectively. - Custom UE environments, assets, and agent models can be imported, extending the simulator beyond its bundled content.
- Gym-like interaction and concrete Communicator APIs support navigation tasks, reward functions, and automated evaluation loops.
- Adoption has substantial hardware and storage costs: at least 6GB of dedicated VRAM, 32GB RAM, and 50–200GB of disk space.
- The Python package is not a complete standalone runtime; it depends on a separately downloaded and launched UE server.
- The example selects
gpt-4o, but credential setup, model costs, rate limits, and model-call failure handling are not documented in the supplied material. - A unified training and evaluation framework, RL pipeline, 1K-plus city-scale multi-agent simulation, and MuJoCo integration remain roadmap items.
- Arbitrary natural-language grounding into UE actions is not yet complete; the shown workflow parses a constrained action string and calls explicit APIs.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| SimWorld Embodied Agent Simulator This agent | 42 · Major gaps | Library / SDKFree + model costs | ★ 787 | 3mo ago | Python | — |
| RLinf RL Infrastructure | 35 · Major gaps | Library / SDKFree | ★ 5.4k | 1d ago | Python | — |
| EDSL (Expected Parrot Domain-Specific Language) | 63 · Some gaps | Library / SDKFree + model costs | ★ 497 | 4d ago | Python | OpenAI API · Claude API |
| MobileGym | 50 · Major gaps | CLIFree + model costs | ★ 800 | 5d ago | Python | — |
How does FollowAgents rate this agent?
Why each dimension lost points
The README gives a basic account of the Python client, UE backend, LLM, camera observations, and action commands, and it exposes effects such as generation, movement, spawning, and environment clearing. This earns limited data-flow and external-effect credit. Deductions apply because there is no least-privilege model, pre-action confirmation, sensitive-data or API-secret policy, dependency integrity/vulnerability control, or recoverable rollback procedure; clear_env is a destructive cleanup API rather than rollback. Repository, documentation, paper, and community references provide partial attribution, but the object names SimWorld-AI while one badge points to maitrix-org, and publisher identity is unverified, so provenance remains limited.
The architecture, setup, configuration, and usage levels are broadly coherent. However, the quick example is explicitly simplified and references uninitialized or undefined values including self.config, self.map, agent_bp, agent_name, duration, observation, position, and success, so it is not a complete internally consistent implementation. Python, operating systems, hardware, UE packages, and startup order are documented adequately, but the large external binaries lack checksums, pinned versions, or an offline alternative. No exception handling, diagnostic workflow, or user-facing failure messages are shown.
The material thoroughly identifies audiences and scenarios spanning quick tests, 100-plus map expansion, custom UE environments/assets/agents, navigation, traffic, generation, and multimodal research. The roadmap distinguishes current from planned capabilities, although a comprehensive agent framework, arbitrary-language actions, RL, and city-scale multi-agent support remain unfinished. Action triggering is only illustrated through startswith parsing and omitted code, without a strict grammar, validation, or ambiguity handling. Windows/Linux, Python, GPU, memory, disk, configuration overrides, and custom packages are documented, but broader platform compatibility and resource-degradation options are not.
Architecture, project tree, quick tour, setup, configuration, API references, customization, and roadmap are organized clearly, justifying full information-architecture credit. Installation guidance is concrete but relies on external UE packages and linked documentation and lacks locked versions, checksums, and complete troubleshooting. Naming/provenance is weakened by the SimWorld-AI versus maitrix-org link inconsistency and the absence of a stability policy. A minimal example and examples directory are supplied, but there is no FAQ and the shown example is incomplete. Hardware requirements and unfinished roadmap items disclose some limitations, but known failures and operational boundaries are not systematically documented. The complete Apache-2.0 text earns full license credit. News entries are not a formal versioned changelog; contribution and Slack links suggest an update path, but the supplied sources do not identify maintainers, support commitments, or release ownership.
The Gym-like interface, observation structure, action calls, configuration path, and API index are practically useful for research prototyping, while physical/social simulation, extensible maps, and multimodal agent interfaces offer meaningful value beyond generic agent scaffolding. Deductions reflect the heavily abbreviated central example and absence of source-backed benchmark outcomes, task results, or output-quality evidence. The README candidly states requirements of at least 6GB VRAM, 32GB RAM, and 50–200GB storage, but provides no installation-time, runtime, model/API cost, or benefit comparison.
Major capabilities are commonly tied to project directories, examples, code locations, configuration files, documentation, or a paper, giving good claim traceability. Cross-source corroboration is limited because only README and LICENSE contents are supplied here, so the referenced code, documentation, paper, and demonstrations cannot be compared within this assessment. Existing features, optional extensions, and unfinished roadmap items are generally separated clearly, but promotional claims such as accurate physics, seamless integration, and robustness lack supporting measurements or qualifications in the supplied evidence.
- Not found in source: least-privilege scopingGrant only what the task needs: a dedicated account or read-only token, scoped to specific directories and repos.
- Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
- Not found in source: sensitive-data handlingUse dedicated, low-privilege, revocable API keys — never production credentials — and keep secrets out of logs.
- Not found in source: dependency securityPin versions and run a dependency audit (npm audit, pip-audit) before installing; prefer running it in a container.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- The quick-tour code is abbreviated and contains several undefined or uninitialized values; it should not be treated as directly runnable.
- The UE server and maps are large external downloads; independently verify their source, version, licensing, and file integrity before installation.
- No policy is shown for API keys, sensor data, prompts, or other sensitive-data handling and retention.
- Spawn, movement, world generation, and clear_env mutate simulator state, but the material provides no confirmation gate, transaction boundary, or recovery procedure.
- Hardware and storage costs are substantial, while no performance benchmark or cost-benefit evidence supports scaled adoption.
- Repository, badge, and publisher attribution signals are not fully consistent; maintenance ownership and the authoritative release channel require separate confirmation.
FAQ
Can I run SimWorld after installing only the Python package?
Is GPT-4o mandatory?
BaseLLM("gpt-4o"), but the architecture targets LLM/VLM agents and does not document ready-made adapters for other providers. Switching models may require configuration or integration work.What environments are included in the basic installation?
.pak files.Can I use my own Unreal Engine content?
.pak files and imported into SimWorld.