Where Plume3D fits
We make Plume3D. This page is not independent. It exists because the honest answer to “how does this compare to Godot, Unity or Unreal?” is it depends, and mostly it does not yet — and because a comparison we publish ourselves is only worth reading if it is specific enough to be proved wrong. Every claim below cites something you can check without taking our word for it.
Plume3D is seven months old and has one contributor. Godot, Unity and Unreal have a combined head start of roughly 61 years. Read the gaps as the point of the page, not as an apology.
How to read this
Section titled “How to read this”A capability is marked Ships only if it is first-party, present in a default install, in a stable release, and documented. That bar is deliberately strict and it is applied to every engine equally — including ours, which is why Plume3D shows a lot of No.
| Marker | Meaning |
|---|---|
| Ships | First-party, default install, stable release, documented. |
| Partial | Present but materially short of the definition. The note names what is missing. |
| Third-party | The real-world solution comes from outside the engine team. The note names it. |
| No | Absent. |
Every competitor claim is sourced from public vendor documentation and release notes — not from hands-on evaluation, and not from performance measurement of any kind. Plume3D claims cite an ADR or a file in the engine repository.
Capability coverage
Section titled “Capability coverage”How many of the 57 tracked capabilities each engine ships, by the definition above.
That count is a floor, not a score. It weights a cinematic sequencer the same as rigid-body physics, and it says nothing about how well anything is implemented. It is here because it is the one number on this page that is reproducible from the data — count the Ships cells yourself.
What moved
Section titled “What moved”Revision 1 is the baseline. Nothing has moved yet — there is only one reading. What follows is where the engine stands today and, in How Plume3D got here, when each capability actually arrived. The next reading is due 2027-02-24; from then on this section will list what changed and what did not.
Baseline reading. Plume3D ships 19 of 57 tracked capabilities; the three established engines ship 42, 49 and 54. The gaps are concentrated in editor iteration, platform reach and ecosystem — not in the runtime.
A trend line needs three readings. This is number 1.
The comparison
Section titled “The comparison”Rendering
Section titled “Rendering”What the renderer can put on screen.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Physically-based materialsA PBR material model (metallic/roughness or equivalent) with texture maps, available by default. | ShipsMetallic/roughness materials with texture maps, imported from Blender.ADR 0055 | ShipsStandardMaterial3D/ORMMaterial3D metallic-roughness PBR with albedo, metallic, roughness, normal and AO maps in the default install.Godot docs — StandardMaterial3D | ShipsURP and HDRP Lit shaders use a metallic/smoothness GGX model with albedo, normal, occlusion and emission maps.Unity Manual — URP Lit shader | ShipsMetallic/roughness PBR material model with texture inputs; the newer Substrate slab-based authoring is enabled by default in new 5.8 projects.Epic docs — Physically Based Materials |
| Real-time shadow mappingReal-time shadows cast by dynamic lights onto dynamic geometry. | ShipsUp to 4 shadow maps, 1024px by default.vulkan_renderer.h | ShipsReal-time shadow maps from DirectionalLight3D, OmniLight3D and SpotLight3D onto dynamic geometry, with per-light bias controls.Godot docs — Lights and shadows | ShipsReal-time shadow maps cast by directional, spot and point lights onto dynamic geometry.Unity Manual — Shadow mapping | ShipsDynamic shadows from movable lights onto dynamic geometry; Virtual Shadow Maps is the default shadow map method for new projects.Epic docs — Virtual Shadow Maps |
| Cascaded shadow mapsCascaded/parallel-split shadow maps for large outdoor scenes, first-party. | NoNo cascaded or parallel-split shadows, so shadow precision falls off across a large outdoor scene. | ShipsDirectionalLight3D uses Parallel Split Shadow Maps; the default directional shadow mode is PSSM with 4 splits.Godot docs — Lights and shadows (PSSM) | ShipsCascaded (parallel-split) shadow maps for directional lights; cascade count and split distances are configurable.Unity Manual — Shadow cascades | ShipsCascaded Shadow Maps for Directional Lights, splitting the view frustum into distance-based cascades of decreasing resolution.Epic docs — Shadowing in Unreal Engine |
| Real-time global illuminationA dynamic indirect-lighting solution shipped as a documented, stable feature. | NoLighting is direct plus a global ambient term. No dynamic indirect solution. | ShipsSDFGI and VoxelGI provide dynamic indirect lighting as documented stable features; both require the Forward+ renderer.Godot docs — Using SDFGI | ShipsHDRP Screen Space Global Illumination volume override, with ray-traced GI layered on the same override.Unity Docs — HDRP Screen Space Global Illumination | ShipsLumen is the default dynamic global illumination and reflections system, with software and hardware ray tracing modes.Epic docs — Lumen Global Illumination and Reflections |
| Hardware ray tracingA high-level, documented ray-tracing feature — not merely low-level API plumbing. | NoNo ray-tracing pipeline of any kind. | PartialRenderingDevice exposes experimental acceleration-structure and ray-tracing-list APIs (blas_create/blas_build); no high-level ray-tracing feature.Godot docs — RenderingDevice (acceleration structures) | ShipsHDRP ray-traced shadows, reflections, global illumination and path tracing; requires DirectX 12.Unity Docs — HDRP set up ray tracing | ShipsHardware ray tracing for shadows, reflections, translucency and Lumen, configured from Project Settings; the Path Tracer shares the same architecture.Epic docs — Hardware Ray Tracing |
| Virtualised geometryAutomatic geometry LOD/virtualisation of the Nanite class. | NoMeshes render at authored density; no automatic geometry virtualisation. | PartialAutomatic mesh LOD generation at import via meshoptimizer plus visibility ranges; no virtualised micropolygon geometry system.Godot docs — Mesh level of detail | PartialMesh LOD generates LODs at import and selects them at runtime; no cluster-based virtualised geometry streaming.Unity Manual — Introduction to Mesh LOD | ShipsNanite provides automatic LOD and streaming for Static Meshes and Geometry Collections; the Nanite Foliage path is Experimental in 5.8.Epic docs — Nanite Virtualized Geometry |
| Composable post-process stackA stack of post-process effects composable by the game without engine changes. | ShipsA stackable chain of post effects composable from game code.ADR 0101 | ShipsStable Environment stack (glow, SSAO, SSIL, SSR, DOF, tonemap) and screen-reading shaders; CompositorEffect custom passes are marked experimental.Godot docs — The Compositor | ShipsVolume framework stacks post-process overrides; custom effects are added as Renderer Features from project code.Unity Manual — Custom post-processing with Volume | ShipsPost Process Volumes stack built-in effects, and projects can add their own post-process materials without engine changes.Epic docs — Post Process Effects |
Physics
Section titled “Physics”Simulation, collision, and character movement.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Rigid-body dynamicsA 3D rigid-body solver with the standard primitive and mesh collider shapes. | ShipsJolt-backed, with 7 shape types including convex hull, mesh and heightfield.ADR 0011 | ShipsJolt is the default 3D backend for new projects since 4.6; RigidBody3D with box, sphere, capsule, convex and concave shapes.Godot docs — Using Jolt Physics | ShipsBuilt-in Rigidbody solver with mass, damping, gravity and axis constraints, colliding via box, sphere, capsule and mesh colliders.Unity Manual — Rigidbody component reference | ShipsChaos physics provides rigid-body dynamics with box, sphere, capsule, convex and triangle-mesh collision shapes.Epic docs — Physics in Unreal Engine |
| Character controllerA first-party kinematic character controller with slope and step handling. | ShipsKinematic controller with slope and step handling.character_controller.h | PartialCharacterBody3D handles slopes via floor_max_angle and floor_snap_length; no built-in stair/step-offset handling.Godot docs — CharacterBody3D | ShipsCharacterController component with Slope Limit and Step Offset properties and Move/SimpleMove.Unity Manual — Character Controller | ShipsCharacter Movement Component handles walking, falling, swimming and flying, with Max Step Height and Walkable Floor Angle properties.Epic docs — Movement Components |
| Joints created at runtime from scriptPhysics joints/constraints constructible at runtime from the scripting layer, not only from imported scene data. | PartialSix joint types exist, but only constructible from Blender-authored scene data — there is no script-side joint builder. | ShipsJoint3D nodes (Pin, Hinge, Slider, ConeTwist, Generic6DOF) are scene nodes, so scripts can create and configure them at runtime.Godot docs — Joint3D | ShipsHinge, Fixed, Spring, Character and Configurable joints can be added and configured from C# at runtime.Unity Scripting API — Joint | ShipsPhysics Constraint Components can be created from Blueprints or C++ at runtime, not only placed as level actors.Epic docs — Physics Constraint Component User Guide |
| Cloth and destructionFirst-party cloth simulation and fracture/destruction systems. | NoNo cloth simulation and no fracture or destruction system. | PartialSoftBody3D covers cloth and soft-body simulation; no first-party fracture or destruction system.Godot docs — SoftBody3D | PartialCloth component ships for Skinned Mesh Renderers; no first-party fracture or destruction system.Unity Manual — Cloth | ShipsChaos Destruction with Geometry Collections and fracture tools; the Chaos Dataflow cloth editor became the default cloth editor in 5.8.Epic docs — Chaos Destruction |
| Vehicle physicsA first-party wheeled-vehicle model exposed to game code. | NoNo wheeled-vehicle model is exposed to game code. | ShipsVehicleBody3D and VehicleWheel3D raycast wheel model exposed to script; docs state it is not designed for realistic vehicle physics.Godot docs — VehicleBody3D | ShipsWheel collider with suspension, slip-based tire friction and per-wheel motor, steering and brake torque.Unity Manual — Wheel collider | ShipsChaos Vehicles ships a wheeled-vehicle movement component, a documented setup guide, and a first-party Vehicle project template with three variants.Epic docs — How to Set up Vehicles in Unreal Engine |
Animation
Section titled “Animation”Skeletal animation, blending, and rigging.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Skeletal animation with blendingSkinned skeletal animation with weighted blending between clips. | ShipsWeighted blend tree with clips as leaves, plus masked pose layers.ADR 0017 | ShipsAnimationTree drives skinned Skeleton3D playback with Blend2/Blend3 and BlendSpace1D/2D weighted blending between clips.Godot docs — Using AnimationTree | ShipsSkinned Mesh Renderer with Animator layers and Blend Trees for weighted blending between clips.Unity Manual — Animation Blend Trees | ShipsSkinned skeletal meshes with Animation Blueprint blend nodes and Blend Spaces for weighted blending between clips.Epic docs — Blend Spaces |
| Animation state machineA named-state graph with guarded transitions, authored as data. | ShipsNamed-state graph with guarded transitions, authored in TOML.ADR 0017 | ShipsAnimationNodeStateMachine graph of named states with transitions guarded by advance conditions and expressions, authored in the editor.Godot docs — AnimationTree StateMachine | ShipsAnimator Controller asset: named states, sub-state machines and transitions guarded by parameter conditions.Unity Manual — Animator Controllers | ShipsState Machines in the Animation Blueprint AnimGraph, with named states and boolean transition rules stored in the asset.Epic docs — State Machines |
| Root motionDriving character movement from animation-authored root displacement. | ShipsRead-only extraction of authored root displacement.ADR 0027 | ShipsAnimationTree root motion track with get_root_motion_position/rotation/scale and the RootMotionView helper node.Godot docs — AnimationTree root motion | ShipsApply Root Motion on the Animator drives displacement from the clip; OnAnimatorMove hands it to script.Unity Manual — How Root Motion works | ShipsEnable Root Motion on an Animation Sequence or Montage to drive character movement from the root bone's authored displacement.Epic docs — Root Motion |
| Runtime IK solverAn inverse-kinematics solver evaluated at runtime (foot planting, look-at, two-bone). | NoNo IK solver runs in the engine. IK exists only inside the offline Blender retargeting tool. | ShipsIKModifier3D solvers TwoBoneIK3D, FABRIK3D, CCDIK3D, SplineIK3D and JacobianIK3D, added in 4.6, alongside the earlier LookAtModifier3D.Godot Engine — 4.6 release notes (IKModifier3D) | ShipsAnimation Rigging constraints (Two Bone IK, Chain IK, Multi-Aim) evaluated at runtime; Animator IK callbacks for humanoids.Unity Docs — Animation Rigging Two Bone IK | ShipsIK Rig solvers and Control Rig Full-Body IK evaluate at runtime, covering foot placement, look-at and two-bone setups.Epic docs — Control Rig Full-Body IK |
| Animation retargetingRetargeting clips between skeletons of differing proportions. | PartialOffline only — the ARP bridge bakes retargeted clips in Blender. Nothing retargets at runtime. | ShipsSkeletonProfile/BoneMap retargeting with rest-pose overwrite and position-track normalisation for differing heights; RetargetModifier3D at runtime.Godot docs — Retargeting 3D skeletons | ShipsHumanoid Avatar retargeting maps clips between skeletons of differing proportions.Unity 6.5 Manual — Retarget humanoid animation | ShipsIK Retargeter transfers animation between skeletons with differing bone counts, names, orientations and proportions.Epic docs — IK Rig Animation Retargeting |
| Motion matchingPose-search-driven animation selection from a motion database. | NoNo pose search and no motion database. | Third-partyNot first-party; GuilhermeGSousa/godot-motion-matching is a maintained C++ GDExtension that builds a pose database from animation libraries.godot-motion-matching (GuilhermeGSousa) | Third-partyNo first-party motion-matching package; the de-facto solution is Motion Matching for Unity (MxM) and its community fork.MxM for Unity (community fork) docs | ShipsMotion Matching via the Pose Search plugin, production-ready since 5.4, with pose databases, schemas and debugging tools.Epic docs — Motion Matching |
AI & behaviour
Section titled “AI & behaviour”Decision-making, perception, and navigation.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Behaviour trees with a blackboardA behaviour-tree runtime plus a shared blackboard, first-party and in a default install. | ShipsBehaviour-tree runtime with a blackboard, authored as .bt.toml in a visual editor app.ADR 0065 | Third-partyNot in a default install; LimboAI (limbonaut) supplies behaviour trees, a blackboard and a tree editor as a module or GDExtension.LimboAI (limbonaut) | ShipsUnity Behavior package: behaviour graphs with action, modifier and sequencing nodes plus Blackboard variables.Unity Docs — Behavior Blackboard variables | ShipsBehavior Tree assets paired with Blackboard assets holding user-defined keys shared across tasks and decorators.Epic docs — Behavior Trees |
| Navmesh baking and pathfindingBaking a navigation mesh from level geometry and querying paths across it. | PartialRecast/Detour baking and corridor pathfinding, but single-tile and non-volumetric — no multi-tile streaming or off-mesh volumes. | ShipsNavigationRegion3D bakes a NavigationMesh from scene geometry; NavigationServer3D and NavigationAgent3D query paths across it.Godot docs — Using navigation meshes | ShipsAI Navigation package: NavMesh Surface bakes navmesh from scene geometry, NavMeshAgent queries and follows paths.Unity Docs — AI Navigation, Create a NavMesh | ShipsThe Navigation System generates a tiled navigation mesh from level collision geometry and answers pathfinding queries.Epic docs — Navigation System |
| Perception / sensingA first-party sight/hearing model feeding agent decision-making. | ShipsSight, sound and light-level sensing feeding agent decisions, with aggro and tension modelling.ADR 0067 | NoNo first-party sight or hearing model; the navigation section covers pathfinding, agents and avoidance only.Godot docs — Navigation section index | Third-partyNo first-party sight/hearing model for agents; Asset Store packages such as Senses 3 (AI Vision, Hearing & Smell) supply it.Unity Asset Store — Senses 3 | ShipsAI Perception Component with sight, hearing, damage and team senses feeding the AI Controller.Epic docs — AI Perception |
| Spatial reasoning queriesScored spatial queries for tactical positioning (cover, flanking, standoff), of the EQS class. | PartialA surround-ring solver spaces attackers around a target, but there is no general scored spatial query system. | Third-partyNo first-party EQS-class system; GEQO (geqo-godot) provides node-based environment queries with generators and scoring tests.GEQO — Godot Environment Query Orchestrator | NoNo first-party EQS-class scored spatial query system; Unity Behavior supplies behaviour graphs and blackboards only.Unity Docs — About Unity Behavior | ShipsEnvironment Query System runs generator plus scored test queries for positioning, callable from Behavior Trees.Epic docs — Environment Query System |
| Crowd / local avoidanceReciprocal local avoidance between many moving agents. | NoThe ring solver spaces encounter participants; there is no reciprocal local avoidance between agents. | ShipsNavigationAgent3D reciprocal avoidance with radius, neighbor_distance, max_neighbors, time_horizon_agents and avoidance_priority.Godot docs — Using NavigationAgents | ShipsNavMeshAgent local avoidance uses reciprocal velocity obstacles, with a selectable avoidance quality level.Unity Docs — AI Navigation, inner workings of the navigation system | ShipsTwo first-party local avoidance methods: RVO on the Character Movement Component, and Detour Crowd via the DetourCrowdAIController class.Epic docs — Using Avoidance With the Navigation System |
Networking
Section titled “Networking”Multiplayer transport and state synchronisation.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Reliable and unreliable transportA first-party networking transport offering both reliable-ordered and unreliable channels. | ShipsGameNetworkingSockets, offering reliable-ordered and unreliable UDP channels.ADR 0003 | ShipsENetMultiplayerPeer with reliable, unreliable and unreliable_ordered RPC transfer modes and multiple channels per connection.Godot docs — High-level multiplayer | ShipsUnity Transport pipelines offer ReliableSequenced and UnreliableSequenced stages over UDP.Unity Docs — Unity Transport pipelines | ShipsBuilt-in net driver carrying replicated properties plus RPCs that are unreliable by default and can be marked Reliable.Epic docs — Remote Procedure Calls |
| Dedicated server modeRunning the simulation headless as an authoritative server. | ShipsHeadless authoritative server mode with its own tick loop.ADR 0003 | ShipsDedicated Server export mode strips client-only resources; the headless display server runs the build without a GPU or display.Godot docs — Exporting for dedicated servers | ShipsDedicated Server build target for Windows, macOS and Linux; headless executable with no graphical interface.Unity Manual — Introduction to Dedicated Server | ShipsDedicated server target runs the simulation headless as the authority, without rendering or local-player logic.Epic docs — Networking Overview |
| Automatic state replicationEngine-driven synchronisation of entity state from server to clients. | ShipsServer-authoritative snapshots, with clients interpolating between the two most recent.ADR 0005 | ShipsMultiplayerSynchronizer replicates configured node properties from the authority to peers; MultiplayerSpawner replicates node creation.Godot docs — MultiplayerSynchronizer | ShipsNetcode for GameObjects NetworkVariable and NetworkTransform synchronise entity state from the authoritative server.Unity Docs — NGO NetworkVariables | ShipsServer-to-client property replication is the default system; the Iris replication system is opt-in and Experimental in 5.8.Epic docs — Networking and Multiplayer |
| Delta-compressed replicationSending only what changed against a per-client acknowledged baseline. | NoSnapshots carry full state; there is no per-client acknowledged baseline to diff against. | PartialREPLICATION_MODE_ON_CHANGE with delta_interval sends only changed properties; no per-client acknowledged baseline.Godot docs — MultiplayerSynchronizer delta_interval | ShipsNetcode for Entities delta-encodes ghost payload and changemask against up to three client-acked baselines.Unity Docs — Netcode for Entities, manage serialization costs | ShipsOnly properties changed since the connection's acknowledged state are sent; Fast TArray replication delta-serialises array items.Epic API reference — FFastArraySerializer |
| Client prediction and reconciliationClient-side predicted movement with server reconciliation and replay. | NoClients interpolate received snapshots. There is no local prediction and no server reconciliation. | Third-partyNo first-party prediction or reconciliation; the netfox addon (foxssake) adds client-side prediction and server reconciliation.netfox (foxssake) | ShipsNetcode for Entities rolls back and re-simulates from the latest snapshot with smoothing; NGO offers client anticipation.Unity Docs — Netcode for Entities prediction | ShipsCharacter Movement Component predicts moves locally, buffers saved moves, and replays them after a server correction.Epic docs — Understanding Networked Movement in the CMC |
| Interest managementRestricting what each connection receives by relevance, typically spatial. | ShipsPer-connection spatial interest radius restricts each client's snapshot to nearby entities.ADR 0117 | ShipsMultiplayerSynchronizer per-peer visibility: set_visibility_for, add_visibility_filter callables and public_visibility.Godot docs — MultiplayerSynchronizer visibility | ShipsNetcode for Entities ghost relevancy sets and per-ghost importance scaling; NGO has NetworkShow/NetworkHide.Unity Docs — Netcode for Entities, ghost optimization | ShipsActors are culled per connection by relevancy and Net Cull Distance; the Replication Graph plugin adds spatial node-based prioritisation.Epic docs — Replication Graph |
Scripting
Section titled “Scripting”Authoring game logic, and the tools around it.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| First-party scripting languageA supported scripting layer for game logic, shipped and documented with the engine. | ShipsWren. 93 scripting classes, most of them bound directly to engine subsystems.wren_api.cpp | ShipsGDScript ships with the engine and is documented with a language reference, static typing and a style guide; C# in the .NET build.Godot docs — GDScript | ShipsC# with the MonoBehaviour component model, documented in the manual and the Scripting API reference.Unity Manual — Introduction to programming in Unity | ShipsBlueprint is the shipped and documented scripting layer for game logic, compiled and executed by the engine.Epic docs — Overview of Blueprints Visual Scripting |
| Script hot reloadEditing game-logic source and seeing the change without restarting the running game. | PartialWatches the config file, the entry script and shader sources only — editing any other script module still needs a restart. | ShipsDebug > Synchronize Script Changes reloads scripts edited in the editor into the running project.Godot docs — Overview of debugging tools | PartialScript Changes While Playing can recompile and continue Play mode, but the domain reload resets any non-serializable state.Unity 6.5 Manual — General preferences reference | ShipsLive Coding rebuilds and patches C++ binaries while the editor or a PIE session runs; header and constructor edits still need a restart.Epic docs — Using Live Coding to Recompile at Runtime |
| Step debugger for game codeBreakpoints, stepping and variable inspection in the engine's own scripting layer. | NoEditor extensions give completion and API awareness, but there are no breakpoints, stepping or variable inspection. | ShipsEditor debugger with breakpoints, step into/over, stack trace, variable inspection and an expression evaluator for GDScript.Godot docs — Debugger panel | ShipsAttach Visual Studio, Rider or VS Code to the Editor or a development player for breakpoints and variable inspection.Unity Manual — Debug C# code in Unity | ShipsBlueprint Debugger provides breakpoints, stepping, watch values and a call stack spanning Blueprint and native frames.Epic docs — Blueprint Debugger |
| Native / C++ extension pathExtending the engine in a compiled language through a supported path. | ShipsThe engine is C++; subsystems are CMake modules built against a device-free core.modules/ | ShipsGDExtension with the official godot-cpp bindings loads compiled C++ libraries at runtime without recompiling the engine.Godot docs — C++ (godot-cpp) / GDExtension | ShipsNative plug-ins in C, C++ or Objective-C through the documented low-level plug-in interface (IUnityInterfaces).Unity Manual — Native plug-ins | ShipsC++ is a first-class authoring path for gameplay classes and for plugins compiled against the engine source.Epic docs — Programming with C++ |
| General visual scriptingNode-graph authoring of general gameplay logic, not restricted to one subsystem. | PartialA behaviour-tree editor covers AI authoring. There is no general-purpose gameplay node graph. | Third-partyVisualScript was removed in 4.0; Orchestrator (CraterCrash) provides node-graph gameplay scripting as a GDExtension.Orchestrator (CraterCrash) | ShipsUnity Visual Scripting package: node graphs for general gameplay logic, with custom node support.Unity Manual — Visual Scripting | ShipsBlueprint node graphs author general gameplay logic and are not scoped to a single subsystem.Epic docs — Blueprints Visual Scripting |
Asset pipeline
Section titled “Asset pipeline”Getting art and data into the engine.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| glTF importImporting glTF 2.0 scenes and meshes. | NoNo glTF reader. The import path is .blend. | ShipsImports glTF 2.0 in both .gltf and .glb form; documented as the recommended 3D interchange format.Godot docs — Available 3D formats | ShipsUnity glTFast package (com.unity.cloud.gltfast) imports glTF 2.0 in the Editor and at runtime; installed from Package Manager.Unity Docs — Unity glTFast | ShipsglTF 2.0 scene and mesh import through the Interchange framework, with a separate first-party glTF exporter.Epic docs — The glTF Format in Unreal Engine |
| FBX importImporting FBX without requiring a separate DCC application at import time. | PartialOffline conversion through Blender only — the engine itself cannot read an FBX file. | ShipsFBX is imported by the built-in ufbx importer by default since 4.3; no external converter or DCC installation required.Godot docs — Available 3D formats (ufbx) | ShipsFBX is Unity's primary model format and imports natively, with no DCC application needed at import time.Unity Manual — Model file formats reference | ShipsFBX 2020.2 import pipeline built into the editor, covering static meshes, skeletal meshes, animation and morph targets.Epic docs — FBX Content Pipeline |
| Direct .blend importReading Blender's native .blend format directly, without exporting to an interchange format. | ShipsReads .blend natively through a DNA-reflective parser, with no Blender installation needed at runtime.blend_load | PartialAccepts .blend files, but requires a local Blender installation and converts through Blender's glTF exporter.Godot docs — Available 3D formats (.blend) | PartialRequires a local Blender install: Unity launches Blender's FBX exporter to convert the .blend at import time.Unity Manual — Proprietary model file formats | NoNo .blend reader in the import pipeline; Blender content arrives as FBX, glTF, USD or Alembic — including via Epic's own Send to Unreal add-on.Epic — Send to Unreal (Blender add-on) docs |
| Drag-and-drop asset importDropping an asset file into an editor window to import and register it. | NoA whole project folder can be dropped onto a running engine, but individual assets cannot be imported that way. | ShipsFiles dragged from the OS file manager into the editor's FileSystem dock are imported and registered, creating a .import file.Godot docs — Import process | ShipsDragging a file from the OS file browser into the Project window copies it into Assets and registers it in the asset database.Unity Manual — Import assets | ShipsDragging files into the Content Browser opens the import options dialog and registers the resulting assets.Epic docs — Importing Assets Directly |
| Asset streaming / bundlingA first-party system for bundling and loading assets on demand at runtime. | PartialContent ships in a mounted .p3d archive. There is no on-demand streaming or addressable bundle system. | ShipsPCK/ZIP resource packs exported from the editor and mounted at runtime via ProjectSettings.load_resource_pack for DLC and patches.Godot docs — Exporting packs, patches and mods | ShipsAddressables packs assets into AssetBundles and loads them asynchronously on demand, locally or from a URL.Unity Manual — Addressables | ShipsAsset Manager with asynchronous streamable loading, chunked pak cooking for patches and DLC, and Level Streaming.Epic docs — Asset Management |
| Platform texture compressionAutomatic transcoding to platform GPU texture formats (BC / ASTC / ETC) at build time. | NoTextures ship in their source format; no build-time BC, ASTC or ETC transcoding. | ShipsImport-time VRAM compression to BPTC/S3TC on desktop and ASTC/ETC2 on mobile and web, selected for the target platform.Godot docs — Importing images | ShipsThe Editor converts textures to the target platform format (BC, ASTC, ETC2) at build time, with per-platform overrides.Unity Manual — Choose a GPU texture format by platform | ShipsCooking transcodes textures to per-platform GPU formats including BC, ASTC and ETC2; Oodle Texture is the shipped encoder.Epic docs — Texture Format Support and Settings |
Editor & tooling
Section titled “Editor & tooling”Building levels and diagnosing problems.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Visual scene / level editorPlacing and arranging level content visually, with an inspector for per-object properties. | PartialBlender with the Plume3D add-on is the level editor — hierarchy, transforms, physics, lights and cameras all round-trip. There is no in-engine editor. | ShipsEditor 2D/3D viewport with the Scene dock for the node hierarchy and the Inspector for per-node property editing.Godot docs — First look at the editor | ShipsScene view with transform gizmos for placing content, and the Inspector for per-object component properties.Unity Manual — Scene view reference | ShipsLevel Editor places and arranges actors in a viewport, with a Details panel exposing per-object properties.Epic docs — Level Editor |
| Live scene reloadA level edit appearing in the running game without restarting it. | NoA .blend edit requires restarting the game. Only config, the entry script and shaders reload live. | ShipsDebug > Synchronize Scene Changes replicates editor scene edits into the running project; the Remote tree edits live nodes.Godot docs — Overview of debugging tools | ShipsScene and Inspector edits made during Play mode apply to the running game immediately; they reset when Play mode exits.Unity Manual — Game view reference | ShipsSimulate In Editor runs the level with editor tools live, allowing actors to be modified or placed; Keep Simulation Changes writes edits back.Epic docs — In-Editor Testing (Play & Simulate) |
| First-party profilerA shipped CPU/GPU/memory profiler for diagnosing performance in your own game. | NoNo first-party CPU, GPU or memory profiler ships with the engine. | ShipsDebugger panel ships script Profiler, Visual Profiler for CPU/GPU render cost, Monitors, Network Profiler and Video RAM tabs.Godot docs — Debugger panel | ShipsUnity Profiler modules for CPU, GPU, memory, rendering and audio, in the Editor or attached to a player.Unity Manual — Unity Profiler | ShipsUnreal Insights captures and analyses CPU, GPU, memory and networking traces from the editor or a packaged build.Epic docs — Unreal Insights |
| Frame / graphics debuggerStepping through a rendered frame's draw calls inside first-party tooling. | NoNo first-party frame capture. External Vulkan tooling is the only option. | PartialVisual Profiler reports per-category CPU/GPU render cost; no in-editor frame capture or draw-call-by-draw-call stepping.Godot docs — Debugger panel (Visual Profiler) | ShipsFrame Debugger freezes a frame and steps through individual draw calls with shader and geometry detail.Unity Manual — Frame Debugger | ShipsDumpGPU writes a captured frame's rendering passes and resources to disk for stepping through in the bundled GPU Dump Viewer.Epic docs — GPUDump Viewer Tool |
| Terrain authoringFirst-party terrain sculpting and texture painting. | PartialHeightfield colliders and scatter baking, both authored in Blender. No sculpting or texture painting. | Third-partyNo first-party terrain node; Terrain3D (TokisanGames) provides sculpting, texture painting and holes as a GDExtension.Terrain3D (TokisanGames) | ShipsBuilt-in Terrain component with sculpt-height and Paint Texture brushes and several built-in brush shapes, edited directly in the Scene view.Unity Manual — Create and edit Terrains | ShipsLandscape Sculpt Mode edits heightmaps and Paint Mode blends material layers across the terrain.Epic docs — Landscape Sculpt Mode |
| Cinematic sequencerA timeline tool for authoring cutscenes and cinematic sequences. | NoNo sequencer or timeline tool for cutscenes. | ShipsAnimationPlayer's animation panel and track editor key any node property on a timeline; this is the first-party cutscene authoring tool.Godot docs — Introduction to the animation features | ShipsTimeline sequences animation, audio and activation tracks for cutscenes and gameplay sequences.Unity Manual — Timeline | ShipsSequencer is the multi-track timeline for cutscenes, camera work, animation tracks and rendered output.Epic docs — Cinematics and Movie Making |
Platform reach
Section titled “Platform reach”Where a finished game can actually ship.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Windows, macOS and LinuxProducing a runnable build for all three desktop operating systems. | ShipsWindows, macOS (universal) and Linux, built reproducibly with static-linkage verification.ADR 0112 | ShipsExport presets and templates for Windows, macOS and Linux, each with its own documented export page.Godot docs — Export | ShipsStandalone player builds for Windows, macOS and Linux from one project.Unity — Multiplatform support | ShipsPackaging produces runnable builds for Windows, macOS and Linux.Epic docs — Packaging Your Project |
| iOS and Android packagingProducing an installable mobile application package, not merely compiling for the architecture. | PartialiOS and Android compile in CI as a static library. Neither produces an installable .ipa or .aab. | ShipsAndroid APK/AAB export and iOS Xcode-project export presets, each with a documented platform setup.Godot docs — Export (Android, iOS) | ShipsAndroid APK and AAB packaging with keystore signing; iOS generates an Xcode project that builds the app.Unity Manual — Build for Android | ShipsPackages .ipa for iOS, iPadOS and tvOS and .apk or .aab for Android from the editor's Package Project menu.Epic docs — Packaging and Shipping |
| Web exportExporting a build that runs in a browser. | NoNo web backend and no browser export. | ShipsExporting for the Web produces a browser build as a first-party export platform.Godot docs — Export (Web) | ShipsWeb build target; WebGL2 is the default graphics API and WebGPU is documented as experimental and not recommended for production.Unity 6.5 Manual — Web graphics APIs | NoNo browser export target; the only browser path is Pixel Streaming, which streams a build running on a server rather than exporting one.Epic docs — Sharing and Releasing Projects |
| Console exportFirst-party export to PlayStation, Xbox or Nintendo hardware. | NoA compile-time backend seam exists, but no console backend is implemented and platform SDK access is not held. | Third-partyConsole SDKs are closed and NDA-bound, so the MIT-licensed engine ships no first-party export; W4 Games and RAWRLAB Games supply middleware.Godot Engine — Console support | ShipsFirst-party PlayStation, Xbox and Nintendo Switch modules; access requires platform-holder approval and a Unity Pro or platform licence.Unity — Console game development | ShipsFirst-party PlayStation, Xbox and Nintendo Switch support; access requires a registered developer account with each platform holder.Epic docs — Consoles Development |
| VR / XR supportFirst-party support for head-mounted displays and XR input. | NoNo head-mounted display or XR input support. | ShipsFirst-party OpenXR and WebXR, with controller, hand and body tracking; vendor and Android XR extensions come from the OpenXR Vendors plugin.Godot docs — XR | ShipsOpenXR provider plus the XR Interaction Toolkit for HMD tracking and XR controller input.Unity Manual — XR Interaction Toolkit | ShipsOpenXR plugin for head-mounted displays and XR input, plus platform plugins for PSVR2, ARKit and ARCore; visionOS support is Experimental.Epic docs — Head-Mounted Experiences with OpenXR |
| Code signing and notarisationTooling that signs and notarises a distributable build for desktop OS gatekeepers. | PartialmacOS Developer ID signing and notarisation are proven end to end. Windows Authenticode is implemented but not yet exercised with a real certificate. | ShipsmacOS export preset performs code signing and notarisation from the editor via Xcode notarytool or rcodesign.Godot docs — Exporting for macOS | PartialmacOS signing and notarisation are documented using Apple's codesign and notarytool; no built-in signing step for Windows desktop builds.Unity Manual — Code sign your application | PartialThe modern Xcode workflow signs macOS builds from Project Settings; notarisation and Windows Authenticode signing are left to external tooling.Epic docs — Using Modern Xcode in Unreal Engine |
Ecosystem & support
Section titled “Ecosystem & support”Everything that is not the engine itself.
| Capability | Plume3D | Godot | Unity | Unreal Engine |
|---|---|---|---|---|
| Asset marketplaceA storefront where third parties sell or share ready-made content for the engine. | NoNo storefront and no third-party content for sale or exchange. | ShipsGodot Foundation-run Asset Store, browsable from the editor; third-party assets and plugins, currently free listings, marked beta.Godot Asset Store | ShipsUnity Asset Store; over 12,000 active publishers, who retain 70% of revenue.Unity Asset Store — Start publishing | ShipsFab is Epic's content marketplace, reachable from inside the UE5 editor; it succeeded the Unreal Engine Marketplace in 2024.Epic docs — Fab Documentation |
| Third-party plugin ecosystemA meaningful body of engine extensions authored by people outside the engine team. | NoNo third-party extensions exist. Every line of the engine and its tooling has one author. | ShipsAsset Store and GDExtension host editor plugins and engine extensions authored outside the Godot team.Godot Asset Store — plugins | ShipsThird-party editor extensions and runtime plugins are distributed through the Asset Store's 12,000+ active publishers.Unity Asset Store — Start publishing | ShipsPlugins are discovered from .uplugin descriptors and enabled per project; third-party plugins are distributed through Fab and elsewhere.Epic docs — Plugins in Unreal Engine |
| Reference documentationComplete, searchable API reference documentation published by the engine team. | Ships180 published pages with search, covering 93 scripting classes and 126 runnable example apps.docs.plume3d.com | ShipsSearchable per-version class reference published by the Godot team covering globals, nodes, resources and servers.Godot docs — Class reference | ShipsSearchable Scripting API reference covering UnityEngine and package namespaces, versioned per release.Unity Scripting API reference | ShipsEpic publishes a searchable C++, Blueprint and Python API reference generated from the engine source.Epic docs — Unreal Engine C++ API Reference |
| Community support channelAn active forum, Discord or Q&A venue where users get help from people other than the maintainers. | NoNo forum, Discord or Q&A venue. Support means emailing the person who wrote it. | ShipsGodot lists the Godot Forum, Discord and subreddit as user-to-user help and discussion venues.Godot Engine — Community | ShipsUnity Discussions hosts engine, package and platform forums where users answer one another.Unity Discussions | ShipsEpic Developer Community Forums carry user-to-user questions and answers, with Epic staff also participating.Epic Developer Community Forums |
| Independent hiring poolAn established pool of developers who already know the engine and can be hired. | NoNobody has ever been hired for Plume3D experience, because nobody outside the project has any. | ShipsA large user base to hire from: roughly 2M downloads per release, and a community the Godot Foundation reports has doubled in the last two years.Godot Engine — Godot usage and engine growth (2026) | ShipsUnity publishes role-based certifications for programmers and artists, developed with hiring managers to validate skills.Unity — Certifications | ShipsEstablished hiring pool, supported by Epic's Authorized Training Center, Unreal Authorized Instructor and Academic Partner programs.Epic — Training & Academic Partner Programs |
How Plume3D got here
Section titled “How Plume3D got here”When each capability above actually landed, from the engine’s own decision records. These are arrival dates, not past readings of this ledger — the first reading of this page was 2026-08-24. They are here because they are checkable against the repository, and because they show the shape of the last few months better than a single snapshot can.
- 2026-01 Native / C++ extension path modules/ First-party scripting language wren_api.cpp Direct .blend import blend_load
- 2026-02 Real-time shadow mapping vulkan_renderer.h Character controller character_controller.h
- 2026-07 Reliable and unreliable transport ADR 0003 Dedicated server mode ADR 0003 Automatic state replication ADR 0005 Rigid-body dynamics ADR 0011 Skeletal animation with blending ADR 0017 Animation state machine ADR 0017 Root motion ADR 0027 Physically-based materials ADR 0055 Behaviour trees with a blackboard ADR 0065
- 2026-08 Perception / sensing ADR 0067 Composable post-process stack ADR 0101 Windows, macOS and Linux ADR 0112 Interest management ADR 0117 Reference documentation docs.plume3d.com
Do not use Plume3D if…
Section titled “Do not use Plume3D if…”- You need to ship on console — No console backend is implemented, and the platform SDK access required to build one is not held. Use Unreal or Unity.
- You need mobile or web — iOS and Android compile only as a static library with no installable package, and there is no web target at all. Use Godot or Unity.
- You iterate on level content all day — A .blend edit needs an app restart — only configuration, the entry script and shaders reload live. Every other engine here shows the edit in a running viewport. Use Godot or Unity.
- You need cloth, destruction, vehicles or motion matching — None of these exist, and none are close. Use Unreal.
- You are hiring, or your team is larger than a few people — There is no marketplace, no third-party ecosystem, no forum, and nobody outside this project has ever used it. Every question routes to one person. Use any of the three.
- You need production-proven stability — Plume3D has never shipped a commercial title. The other three have collectively shipped tens of thousands.
That list is not modesty. Each line is a real limitation with a real cause, and every one of them is a thing the three engines above solved years ago.
Where Plume3D is genuinely ahead
Section titled “Where Plume3D is genuinely ahead”Short list, and every item carries its caveat — an unhedged advantage from a vendor is marketing.
- A first-party AI substrate — Behaviour trees, a blackboard, perception, and aggro/tension modelling ship in the box, with a visual editor authoring trees as data. Godot routes this through the third-party LimboAI. Caveat: three example trees exist in the repository, and the navmesh is single-tile and non-volumetric.
- Blender read natively, with no export step — A DNA-reflective parser reads .blend directly, so the level editor and the engine share one file with no interchange format and no Blender installation at runtime. Caveat: the trade is the restart — this is exactly why live scene reload is missing, and every other engine here has it.
- Reproducible, integrity-checked builds — Shipping builds are byte-reproducible with static-linkage verification, and .p3d packages are signed against a developer-certificate PKI that is verified before any script loads. Caveat: the shipped root key is still the development default, and release provenance signing is implemented but its key material is not yet provisioned.
What this page does not measure
Section titled “What this page does not measure”Deliberately absent, because we cannot measure them fairly or at all:
- Performance — no frame rates, memory figures, or build times for any engine, ours included.
- Stability and production-hardening — Plume3D has shipped no commercial title. The other three have shipped thousands.
- Quality of implementation — “Ships” says a capability exists, not that it is good.
- Iteration speed, team scale, hiring, cost, and licensing terms — all material to a real engine choice, none of them captured here.
Corrections
Section titled “Corrections”If a cell is wrong — especially one about an engine we do not make — it is a bug, and we want it. Email hello@wyldmagic.gg with the capability and a link to the vendor documentation that contradicts us. Factual errors get fixed as soon as they are confirmed; judgement calls get argued about in the next revision, and the change is recorded either way. Corrections from the Godot, Unity and Unreal communities are especially welcome — you know your own engines better than we do.
Godot is a trademark of the Godot Foundation. Unity is a trademark of Unity Technologies. Unreal and Unreal Engine are trademarks or registered trademarks of Epic Games, Inc. These names are used here descriptively to identify the products compared. Plume3D is not affiliated with, endorsed by, or sponsored by any of them.