The Unseen Factors in Bevy vs Godot

If you are a beginner venturing into indie game development, Godot with its intuitive scene design, integrated scripting language, and robust platform support is a go-to choice. Yet, should your needs lean towards data-driven architectures, Bevy‘s Rust-based engine renders a powerful, flexible alternative with a faster compile time.

Key Differences Between Bevy and Godot

• Architecture: Bevy uses a data-driven, Rust-based game engine with Entity Component System (ECS), while Godot relies on scene-driven design using nodes.
• Support: Godot supports Android, desktop, and web platforms, while Bevy currently supports all major platforms excluding Android.
• Language: Bevy relies heavily on Rust language improvements, while Godot uses a built-in scripting language GDscript and supports C# and C++.
• Community: Both provide strong community options, but Bevy places a major emphasis on community contribution and feedback for ongoing development.

What Is Bevy and Who’s It For?

Bevy is a cutting-edge, data-driven game engine crafted with the efficiency of Rust. It brandishes a full arsenal of 2D and 3D features, designed with a strong emphasis on the Entity Component System (ECS) approach. Community options like a dedicated Discord server, GitHub Discussions, and the Bevy Assets collection make it a haven for indie developers and enthusiasts. Albeit, the long-term vision has its sights on larger studios as well.

Despite its comprehensive feature set, its minimal binaries (a little over 1MB for a basic “hello world” game) and speedy compile times (0.8-3.0 seconds) make Bevy incredibly lightweight and efficient.

Pros of Bevy

• Fast compile times
• Wide community support
• Powerful and easy-to-use API
• Support for all major platforms including Web and iOS
• Extensive customization options

Cons of Bevy

• Heavy reliance on Rust language changes can lead to API-breaking changes
• Android support awaited
• Future feature considerations like wasm and webgpu not yet implemented

What Is Godot and Who’s It For?

Godot, an open-source game engine, offers an intuitive, scene-driven design that enables developers to construct games from simple blocks or nodes that can morph into full-featured components. Its in-house scripting language GDscript, along with support for C#, makes for streamlined game logic. Not to mention, the specialized 2D workflow it provides is a boon for game and app creators.

Revered globally, Godot is celebrated for the absence of hidden fees and its open, modifiable codebase. Though it may not be suitable for highly complex 3D game development, Godot stands as the engine of choice for both beginners and experienced game developers, thanks to its flexibility and robust features.

Pros of Godot

• Intuitive scene-driven design
• Built-in scripting language
• Free and modifiable
• Platform diverse, including Android phones support in Godot 3.5
• Support for regular updates and improvements

Cons of Godot

• Not ideal for complex 3D game development
• .NET support limited to desktop platforms
• Node organization may be confusing for beginners

Bevy vs Godot: Pricing

Both Bevy and Godot are free, open-source game engines licensed under the MIT license.

Bevy

Bevy is free to use for everyone and is licensed under the MIT or Apache 2.0 licenses. This free pricing structure promotes a community-driven approach, encouraging users to contribute to the ongoing development of the engine.

Godot

Similarly, Godot is free and open source, operating under an MIT license. There are no licensing fees, contracts, or hidden charges, facilitating the development of user-owned games without any financial constraints.

Code Examples for Bevy & Godot

Bevy

In this Bevy snippet, we will create a simple 2D game where an entity (sprite) moves towards the mouse click position on the screen. Note: You must have the Bevy crate in your “Cargo.toml” file for the code to function optimally.

// Import necessary modules
use bevy::prelude::*;

fn main() {
    App::build()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup.system())
        .add_system(move_sprite.system())
        .run();
}

// Setup function to spawn entities
fn setup(mut commands: Commands, mut materials: ResMut<Assets<ColorMaterial>>) {
    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
    commands.spawn_bundle(SpriteBundle {
        material: materials.add(ColorMaterial::color(Color::rgb(0.5, 0.5, 1.0))),
        transform: Transform::from_xyz(0.0, 0.0, 0.0), 
        ..Default::default()
    });
}

// System to move the sprite
fn move_sprite(time: Res<Time>, keyboard_input: Res<Input<KeyCode>>, mut query: Query<&mut Transform>) {
    let mut direction = Vec3::ZERO;
  
    if keyboard_input.pressed(KeyCode::Up) {
        direction += Vec3::Y;
    }

    if keyboard_input.pressed(KeyCode::Down) {
        direction -= Vec3::Y;
    }

    if keyboard_input.pressed(KeyCode::Right) {
        direction += Vec3::X;
    }

    if keyboard_input.pressed(KeyCode::Left) {
        direction -= Vec3::X;
    }

    for mut transform in query.iter_mut() {
        transform.translation += time.delta_seconds() * direction * 500.;
    }
}

Godot

This Godot code snippet presents a simple scene where a node (sprite) will rotate towards the position of the mouse click. Note: You must have “Godot 3.2” or later installed for the code to work as expected.

# The Node
extends Sprite

# Variables
var target = Vector2.ZERO

# The Physics Process Function
func _physics_process(delta):
    # Move the Sprite towards the target
    var velocity = (target - position).normalized() * 200
    position += velocity * delta

# Mouse Input Function
func _input(event):
    if event is InputEventMouseButton:
        if event.pressed:
           target = event.position

# Calculate Rotation
func _draw():
   var dir = target - global_position
   draw_line(Vector2.ZERO, dir, Color(1, 1, 1), 2, true)
   rotation = dir.angle()

Bevy or Godot: Which Reigns Supreme?

When the stage sets for a showdown between Bevy and Godot, the choice binds to divergent use-case scenarios and individualistic developer requisites. Let’s dissect this intricate selection.

For the Indie Developer

For the audacious indie developers valuing neatness and compactness, Bevy triumphs. Reasons:

• Speedy compile time
• Data-facilitated 2D/3D rendering
• Engaging open source community
• Size-efficient binaries (~1MB)

The 3D Enthusiast

Godot seizes the laurel for 3D enthusiasts. This allocation roots in:

1. Direct import capability for Blender files
2. 3D engine’s adaptable functionality
3. Auditory innovations like real-time effects

The Budding Game Creator

Emerging game creators might perceive Godot as an attractive choice.

• Intuitive scene-oriented modelling
• Direct scene assembly into operational components
• Accommodation for a gamut of programming languages

The Web-focused Developer

Bevy promises to enchant web-focused developers. Wasm & WebGPU draw these programmers.

• Support for major platforms like Windows, MacOS, Linux, Web, iOS
• Potential for modern web standards

In conclusion, Bevy offers speed, neatness, and promise of web standards, perfect for indie and web-savvy developers. Godot stands tall for 3D enthusiasts and beginners, providing intuitive, flexible modeling, and a range of supported languages. Your tech of choice boils down to your requirements.