Behind the Scenes: Bevy vs Macroquad

For highly efficient 2D rendering and beginner-friendly game development, Macroquad stands out. However, if your focus is comprehensive 2D, 3D features, and a data-oriented architecture, Bevy is the clear choice. Consider the purpose and complexity of your project before selection.

Key Differences Between Bevy and Macroquad

• Bevy caters to extensive 2D and 3D needs with its focus on data-oriented architecture, while Macroquad predominantly provides high efficiency for 2D game development.
• Bevy has a fast compiles configuration ranging 0.8-3.0s, Macroquad requires only 16s after a complete clean.
• While Bevy aims at attracting both indies and large scale studios, Macroquad’s minimalistic design welcomes beginners.
• Both offer community options but Macroquad operates with income from sponsors, investing part of it into hiring contractors.

What Is Bevy and Who’s It For?

Bevy is an advanced, data-driven game engine innovatively constructed in Rust. It seeks to provide a comprehensive catalogue of 2D and 3D attributes with a strong focus on a data-oriented architecture, harnessing the power of the Entity Component System (ECS) paradigm. This beast of a game engine is especially ideal for indie developers and tech enthusiasts, looking to dabble in high-end game development, but holds the promise to attract larger studios in the long run.

Pros of Bevy

• Supports all major platforms, with an incoming Android support.
• Features for 2D/3D rendering, UI functionality, sound loading, among others.
• Rapid compile time, enhancing productivity.
• Open source and free to use.

Cons of Bevy

• Reliance on Rust language and compiler improvements can cause API-breaking changes in newer versions.
• Modern web standards, wasm and webgpu, are only in future considerations.

What Is Macroquad and Who’s It For?

Inspired by the essence of raylib, Macroquad is a user-friendly game library coded in Rust. It uplifts the concept of 2D rendering, boasting a highly efficient automatic geometry batching. Macroquad is a perfect match for beginners in Rust programming, thanks to its minimalist design that keeps complex Rust-specific concepts, such as lifetimes/borrowing, at bay.

Pros of Macroquad

• Powers efficient 2D rendering with automated geometry batching.
• Supports cross-compilation to Windows from Linux.
• Single command deployment for WASM and Android build instructions.
• Minimalistic design, making it beginner-friendly.

Cons of Macroquad

• iOS applications require additional assets for proper functioning.
• Less focused on 3D rendering capabilities.

“

Bevy vs Macroquad: Pricing

Bevy and Macroquad both adopt a free, open-source model, offering high functionality without a monetary investment.

Bevy

Bevy is a game engine offered free of charge. It operates as an open-source project under MIT or Apache 2.0 licenses, providing unrestricted access to its comprehensive feature set for platform expansion, customization, and development.

Macroquad

Macroquad also stakes its position in the open-source space, giving developers free use of its efficient 2D rendering and cross-compilation abilities. It’s partially funded through Patreon, GitHub sponsors, and individual contributions, amounting to $1360/month, which facilitate consistent updates and expansions.”

Code Examples for Bevy & Macroquad

Bevy

Here’s a Bevy snippet for creating an animated 3D sprite. Ensure to have the Bevy version 0.5 installed to execute this code without hitches.

        use bevy::prelude::*;

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

    fn setup(commands: &mut Commands, asset_server: Res<assetserver>, mut textures: ResMut<assets<texture>>) {
        let texture_handle = asset_server.load("branding/icon.png");

        commands
            .spawn(Camera2dBundle::default())
            .spawn(SpriteBundle {
                material: materials.add(texture_handle.into()),
                ..Default::default()
            })
            .with(SpriteTimer(Timer::from_seconds(1., true)));

    }

    struct SpriteTimer(Timer);

    fn animate_sprite_system(time: Res<time>, mut query: Query<(&mut Transform, &SpriteTimer)>) {
        for (mut tx, timer) in query.iter_mut() {
            if timer.0.tick(time.delta()).just_finished() {
                tx.rotate(Quat::from_rotation_z(3.14 / 4.));
            }
        }
    }
    </time></assets<texture></assetserver>
    

Macroquad

This Macroquad example introduces 2D animation basics. It ensures you have the version 0.3.7 to work with in order to execute the code as intended.

        use macroquad::prelude::*;

    #
    async fn main() {
        loop {
            clear_background(RED);

            draw_line(40.0, 40.0, 100.0, 200.0, 15.0, BLUE);
            draw_rectangle(screen_width() / 2.0 - 60.0, 220.0, 120.0, 60.0, GREEN);
            draw_circle(screen_width() / 2.0, screen_height() / 2.0, 80.0, YELLOW);
            draw_text("HELLO", 20.0, 20.0, 20.0, DARKGRAY);

            next_frame().await
        }
    }
    

Which Wins The Day – Bevy or Macroquad?

When choosing between Bevy and Macroquad, factors such as the platform in use, feature requirements, community aid, and design preferences triumph. Let’s break it down for specific user groups:

The Beginner Developer

If you’re just paving your way in game development, Macroquad may be your go-to. Its minimalistic design bypasses complicated Rust-specific concepts like lifetimes/borrowing, making it easier to grasp. In addition, immediate-mode UI library and efficient 2D rendering serve well for beginners.

The Indie Creator

Bevy’s large array of 2D and 3D features, and data-driven game engine brings a comprehensive toolkit to the table for independent creators. With features such as UI functionality, sound loading, hot reloading and an easy-to-use yet potent API, you’d be equipped to craft intricate indie games.

The Collaborative Teams

For larger game development teams, seeking a potent, data-driven engine with plenty of features, look no further than Bevy. With an emphasis on ECS paradigm, it allows for quick, complex iterations of gameplay features and systems. Add in its hot-reloading element and you have an ace team collaboration tool.

Choosing between Macroquad and Bevy boils down to your specific requirements, expertise and goals. Beginners might veer towards Macroquad for its simplicity, whilst Indie creators and collaborative teams could find value in Bevy’s comprehensive, data-driven aspects – but ultimately, the choice is yours.