Behind the Scenes: Bevy vs Piston

When it boils down to Bevy VS Piston, Bevy triumphs for those seeking a comprehensive, data-oriented game engine with a swift compile time and an accessible API. However, Piston, with its optimal modularity and broad collaboration, provides a unique ecosystem for game development, attracting those seeking specific libraries and task-specific core modules.

Key Differences Between Bevy and Piston

• Bevy leverages the Entity Component System paradigm for a data-driven architecture, while Piston adopts a Model-View-Controller pattern for application development.
• Bevy fundamentally focuses on game development, whereas Piston extends its involvement to AI programming, GUI, 2D/3D graphics, and sound/music/network programming.
• Piston affords more modularity, allowing the use of virtually any Rust library, while Bevy offers a variety of cargo features to customize functionality.
• Bevy fosters a more enthusiastic community backing with varied communication channels, while Piston encourages collaboration across multiple libraries and projects.
• Bevy’s API remains stable despite continuous updates. In contrast, Piston’s core has largely remained unchanged since its inception, targeting stability for future updates.

What Is Bevy and Who’s It For?

Bevy is a formidable, data-centered game engine coded in Rust. Providing a robust 2D and 3D feature catalog, Bevy specializes in a data-oriented approach utilizing the Entity Component System paradigm. This powerhouse supports all major platforms and showcases a quick compile time using its ‘fast compiles’ configuration. Yet, it’s more than a tool, it’s a thriving Discord community, an open-source revolution free for everyone, and a platform for enthusiasts and indie game developers alike. Bevy assets add even more potential for customization, with the vision for the engine to cater to larger studios in the long run.

Pros of Bevy

• All-in-one 2D and 3D game engine
• Fosters a highly active community
• Maintains a swift compile period
• Supports all popular platforms
• Open-source and free for everyone

Cons of Bevy

• Dependency on Rust language improvements may cause API-breaking changes
• Android support yet to be offered
• Future plans – networking and editor build – still pending

What Is Piston and Who’s It For?

Piston, a precision-engineered game engine touted for its formidable modularity and groundbreaking Rust-based structure, caters to a robust user base. From game developers looking for a versatile toolkit to hobbyists keen on game mechanics to scholars interested in advanced math-related projects, Piston has them covered. This open-source powerhouse strikes a balance between core game engine needs and expansive Rust ecosystem reach. Piston stands out with its application-specific UIs and collaborations with other entity generals: Gfx-rs (3D graphics) and RustAudio (audio-related).

Pros of Piston

• A robust game engine leveraging Rust’s feature set
• Routines for event handling and advanced event polling
• Exceptional modularity, catering to customisation needs
• Strong multi-library collaboration
• Stability-oriented core updates

Cons of Piston

• Requires a prior understanding of ‘points vs pixels’
• Core stability targeted, but not achieved
• No direct avenue for Android development

“

Bevy vs Piston: Pricing

Bevy and Piston, both free and open-source game engine technologies, present significant value in cost-effectiveness.

Bevy

Bevy is a free, open-source game engine, licensed under the MIT or Apache 2.0 licenses, able to be used, altered, and distributed at no charge. The entire codebase is easily accessible, offering a cost-effective solution for developers.

Piston

Similarly, Piston is also a cost-effective solution for developers as it is available free of charge, operating under open-source parameters. Furthermore, it is part of multiple open-source organizations like PistonDevelopers and AdvancedResearch, highlighting its strong commitment to community collaboration.

Code Examples for Bevy & Piston

Bevy

In this example, we have a fun mini-game. Your entity is a sprite that increases in size every time it intersects with another object (bevy.png). For this, you will need the latest Bevy crate and an image file (bevy.png).

    ```rust
    fn main() {
        App::build()
            .add_plugins(DefaultPlugins)
            .add_resource(CursorPosition::default())
            .add_startup_system(setup.system())
            .add_system(sprite_resize.system())
            .run();
    }

    fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
        let texture_handle = asset_server.load("bevy.png");
        commands.spawn(Camera2dBundle::default());
        commands.spawn(SpriteBundle {
            material: Materials::from(texture_handle),
            transform: Transform::from_xyz(0., 0., 0.),
            ..Default::default()
        });
    }

    fn sprite_resize windows: Res<Windows>, mut query: Query<&mut Transform, With<Sprite>>) {
        let window = windows.get_primary().unwrap();
        let cursor_position = cursor_position.0.unwrap();

        for mut transform in query.iter_mut() {
            if point_in_rect(cursor_position, &transform) {
                transform.scale += Vec3::splat(0.1);
            }
        }
    }
    ```

Piston

This Piston code snippet inscribes a circle that changes color every time you left-click anywhere inside the window. You will need the latest piston_window crate and rand crate for generating random colors.

    ```rust
    extern crate piston_window;
    extern crate rand;

    use piston_window::*;
    use rand::Rng;

    fn main() {
        let mut window: PistonWindow = WindowSettings::new("Color Randomizer", [600, 600])
            .exit_on_esc(true).build().unwrap();
        let mut rng = rand::thread_rng();

        while let Some(e) = window.next() {
            window.draw_2d(&e, |context, graphics, _device| {
                let (x, y) = context.draw_state.get_clip();
                clear([x as f32 /255.0, y as f32 /255.0, 0.0, 1.0], graphics);
            });
            
            if let Some(Button::Mouse(MouseButton::Left)) = e.release_args() {
                let (x, y, z) = rng.gen();
                window.draw_2d(&e, |context, graphics, _device| {
                    let circle = line::circle(0.5, 0.5);
                    line([1.0, 0.0, 0.0, 1.0], 1.0, circle, context.transform, graphics);
                });
            }
        }
    }
    ```

Final Verdict: Bevy vs Piston. Which is the Right Game Engine for You?

As we delve into the comparison between Bevy and Piston, the distinction isn’t simply a matter of technical prowess, but about aligning the characteristics of each engine with the specific needs of different developers.

Indie Developers and Enthusiasts

For indie developers and enthusiasts seeking a complete 2D and 3D capability with efficient Entity Component System (ECS) and quick compile times, Bevy becomes the ideal choice. Bevy also boasts a responsive community, complete with a Discord server, subreddit, and a GitHub Discussion platform – an invaluable asset for independent developers.

Open Source Pioneers

Piston finds its niche in the open-source universe. If you’re keen on experimenting with a variety of libraries from Rust’s ecosystem and working in a collaborative project environment, Piston offers you exactly that, along with its core game-agnostic engine.

Non-Programmer Game Makers

If you’re a game designer with limited programming skills, the use of Dyon, a dynamic scripting language in Piston, tends to simplify the development process. Piston, being an elder statesperson of the two with a track record since 2014, might be more suited to your preference.

In the heated debate of Bevy vs Piston, the sue of Bevy resonates with indie developers and enthusiasts due to its fast compile time, all-inclusive 2D/3D functionality, and proactive community. However, Piston’s open-source collaboration, modularity, and a dynamic scripting language makes it a go-to for open-source advocates and non-programmer game makers.