Bevy vs Amethyst: Which Checks All the Boxes?

Amethyst offers a well-documented design for beginners, but its development is halted so it’s not advisable for commercial projects. Bevy, however, is constantly evolving, prioritizing community contribution. It’s fast, robust, supports major platforms and is geared towards game enthusiasts and indie studios, making it an optimal choice.

Key Differences Between Bevy and Amethyst

• Development Progress: Bevy is consistently updated and active; Amethyst’s development is paused.
• Suitable Audience: Bevy targets indie studios and enthusiasts; Amethyst primarily serves beginners.
• Platform Support: Bevy supports all significant platforms and anticipates Android; Amethyst details unavailable.
• Project Feasibility: Amethyst is considered pre-release, not suitable for commercial projects; Bevy caters to both small and potential larger studios.

What Is Bevy and Who’s It For?

Bevy is a high-performance, data-driven game engine built in Rust designed with a focus on data-oriented architecture using the Entity Component System (ECS) paradigm. The engine is fully equipped with 2D and 3D rendering, robust user interface (UI) functionality, sound loading and hot reloading for real-time feedback. Designed with compatibility in mind, Bevy works seamlessly across a range of major platforms like Windows, MacOS, Linux, Web, and iOS, with Android compatibility anticipated. Strictly intended for development enthusiasts, Bevy is commonly sought by independent creators and is envisioned to eventually appeal to larger studios.

Pros of Bevy

• Wide range of features including 2D/3D rendering and sound loading.
• Quick compile time (0.8-3.0 seconds with ‘fast compiles’).
• Open-source with community support.
• Customizable functionality via cargo features.

Cons of Bevy

• Dependence on Rust language improvements can lead to API changes.
• Anticipated features like wasm, webgpu and Android support yet to be implemented.
• Development is currently aiming at smaller users, could limit larger-studio appeal.

What Is Amethyst and Who’s It For?

Amethyst is a data-driven, data-oriented game engine, originally built with a highly parallel architecture and the Entity Component System (ECS). Designed for rapid prototyping and beginner-friendly experiences, the engine runs concurrently on Rust version 1.47, offering clean interfaces and reusable assets. Although development of Amethyst has been suspended, it was envisioned to cater to developers in the creation of both 2D and 3D games and not intended for large-scale commercial projects due to its current developmental stage.

Pros of Amethyst

• Data-driven approach for creative flexibility.
• Open-source with community support.
• Parallel architecture for improved performance.
• Reusability and clean interface design.

Cons of Amethyst

• Development has been halted.
• Not suitable for large, commercial projects.
• Criticized for being general-purpose without a defined game application.

Bevy vs Amethyst: Pricing

The striking difference between Bevy and Amethyst is that while Bevy is absolutely free, the pricing specifics for Amethyst aren’t readily available.

Bevy

As a free and open-source technology, Bevy allows users unrestricted access to a range of modern game development tools. It operates under flexible MIT or Apache 2.0 licenses, offering tremendous value without a single penny exchanged.

Amethyst

Amethyst, on the other hand, doesn’t list explicit pricing information. Given its continued development and status as a pre-release product, it fails to provide clear cost expectations for users. Importantly, it holds corporate sponsorship from businesses like DigitalOcean and Sentry, signalling the potential for a cost-based pricing structure in the future.

Code Examples for Bevy & Amethyst

Bevy

This code snippet showcases how to create a simple sprite animation in Bevy. This assumes you have the appropriate dependencies in your project and the sprite sheet is correctly set up.

use bevy::prelude::*;
struct Animation {
  frame: u32,
}
fn main() {
    App::build()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup.system())
        .add_system(animate_sprite.system())
        .run();
}
fn setup(commands: &Commands, asset_server: Res<assetserver>) {
    let texture_handle = asset_server.load("spritesheet.png");
    commands.spawn(Camera2dBundle::default())
        .spawn(SpriteBundle {
            texture: texture_handle,
            ..Default::default()
        })
            .with(Animation { frame: 0 });
}
fn animate_sprite(time: Res<time>, mut query: Query<(&mut TextureAtlasSprite, &Animation)>) {
    for (mut sprite, animation) in query.iter_mut() {
        sprite.index = (animation.frame + (time.seconds_since_startup() as u32 * 8) {66f7997927a862c9f57ec7dffc6a2fe6d405caee7001dff533b976d48fe118b1} 8) as u16;
    }
}</time></assetserver>

Amethyst

The following Amethyst code demonstrates how to set up a simple 2D game. Dependencies involving amethyst::prelude, Paddle and Pong components are necessary for effective code execution.

use amethyst::prelude::*;
struct Paddle;
struct Pong;
impl SimpleState for Pong {}
fn main() {
   let game_data = GameDataBuilder::default()
       .with(PaddleSystem, "paddle_system", &[]);
   let mut game = CoreApplication::<_, GameData>::build("/", Pong)?.build(game_data)?;
   game.run();
}
struct PaddleSystem;
impl<'s> System<'s> for PaddleSystem {
   type SystemData = ();
   fn run(&mut self, (): Self::SystemData) {}
}

So, Bevy or Amethyst: Which Tailors to Your Tech-stitch?

Between Bevy’s data-driven dynamics and Amethyst’s pliable parallel architecture, your choice boils down to your specific needs and ambitions. Let’s dive deeper.

For Developers: Pragmatic Programmers

Bevy edges forward for its consistent updates and dynamic community involvement. Rust’s compatibility garners positive views with its fast compile times. However, developers need to anticipate API-breaking changes due to Rust’s constant improvements.

For Game Creators: Design Dreamers

Amethyst could be a better fit for creators seeking a beginner-friendly interface. Despite its development halt, it offers a rich field for rapid prototyping, powered by well-curated documentation and a robust Developer Community.

For Tech Curators: Future-focused Tech Enthusiasts

Bevy’s forward-looking plans of integrating modern web standards such as wasm and webgpu make it the future-oriented choice. Moreover, its stated vision of catering to larger studios set it as the one to watch.

When it boils down to Bevy vs Amethyst, Bevy stands out with its dynamic updates, faster compile times and robust community. However, for beginners and rapid prototypers, Amethyst remains a viable option, despite halted updates.