avian vs bevy_rapier — Side-by-Side Comparison

Cargo.toml Dependencies

Plugin Setup

#![allow(unused)]
fn main() {
// ---- avian3d ----
use avian3d::prelude::*;
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(PhysicsPlugins::default())
    .add_plugins(PhysicsDebugPlugin::default())  // optional debug

// ---- bevy_rapier3d ----
use bevy_rapier3d::prelude::*;
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(RapierPhysicsPlugin::<NoUserData>::default())
    .add_plugins(RapierDebugRenderPlugin::default())  // optional debug
}

RigidBody Types

Note: avian uses a single Kinematic variant; bevy_rapier splits it into position-based and velocity-based.

Collider Creation

Note the parameter order difference: avian generally takes (radius, length) while rapier takes (half_height, radius).

Velocity and Force API

Key difference: avian uses separate components for linear and angular velocity; rapier bundles them into a single Velocity struct.

Collision Events

#![allow(unused)]
fn main() {
// ---- avian ----
fn collisions(
    mut started: EventReader<CollisionStarted>,
    mut ended: EventReader<CollisionEnded>,
) {
    for CollisionStarted(a, b) in started.read() { /* ... */ }
    for CollisionEnded(a, b) in ended.read() { /* ... */ }
}

// ---- bevy_rapier ----
fn collisions(mut events: EventReader<CollisionEvent>) {
    for event in events.read() {
        match event {
            CollisionEvent::Started(a, b, _flags) => { /* ... */ }
            CollisionEvent::Stopped(a, b, _flags) => { /* ... */ }
        }
    }
}
// Note: rapier requires `ActiveEvents::COLLISION_EVENTS` on at least one entity.
}

Collision Layers

#![allow(unused)]
fn main() {
// ---- avian ----
#[derive(PhysicsLayer, Default)]
enum GameLayer { #[default] Default, Player, Enemy }
CollisionLayers::new(GameLayer::Player, [GameLayer::Enemy, GameLayer::Default])

// ---- bevy_rapier ----
const PLAYER: Group = Group::GROUP_1;
const ENEMY: Group = Group::GROUP_2;
CollisionGroups::new(PLAYER, ENEMY | Group::ALL)
}

avian uses a derive macro for named layers. rapier uses bitflag groups.

Sensors

#![allow(unused)]
fn main() {
// ---- avian ----
commands.spawn((Collider::sphere(3.0), Sensor));

// ---- bevy_rapier ----
commands.spawn((Collider::ball(3.0), Sensor, ActiveEvents::COLLISION_EVENTS));
// rapier requires ActiveEvents for sensors to generate events.
}

Raycasting

#![allow(unused)]
fn main() {
// ---- avian (one-shot) ----
fn raycast(spatial_query: SpatialQuery) {
    if let Some(hit) = spatial_query.cast_ray(
        origin, direction, max_distance, solid, &SpatialQueryFilter::default()
    ) {
        // hit.entity, hit.distance
    }
}

// ---- avian (persistent component) ----
commands.spawn(RayCaster::new(Vec3::ZERO, Direction3d::NEG_Y).with_max_distance(100.0));
// Read results from RayHits component each frame.

// ---- bevy_rapier ----
fn raycast(rapier_context: Res<RapierContext>) {
    if let Some((entity, distance)) = rapier_context.cast_ray(
        origin, direction, max_distance, solid, QueryFilter::default()
    ) {
        // entity, distance
    }
}
}

avian offers both a persistent RayCaster component and an on-demand SpatialQuery system parameter. rapier provides only the on-demand RapierContext approach.

Character Controller

#![allow(unused)]
fn main() {
// ---- avian ----
commands.spawn((
    RigidBody::Kinematic,
    Collider::capsule(0.4, 1.0),
    CharacterController,
    LinearVelocity::default(),
));
// Move by setting LinearVelocity directly.

// ---- bevy_rapier ----
commands.spawn((
    RigidBody::KinematicPositionBased,
    Collider::capsule_y(0.5, 0.4),
    KinematicCharacterController {
        max_slope_climb_angle: std::f32::consts::FRAC_PI_4,
        snap_to_ground: Some(CharacterLength::Absolute(0.2)),
        ..default()
    },
));
// Move by setting controller.translation = Some(movement_vector).
// Read KinematicCharacterControllerOutput for grounded state.
}

Joints

avian spawns joints as their own entities. rapier inserts ImpulseJoint as a component on one of the two bodies.

Key Differences and Tradeoffs

When to Choose Which

Choose avian when:

• Starting a new Bevy project with no existing rapier code
• You value Bevy-native, idiomatic component APIs
• Cross-platform determinism matters (e.g., lockstep multiplayer)
• You want a single Rust dependency with no C/C++ in the chain

Choose bevy_rapier when:

• Migrating from an existing rapier-based project
• You need a specific rapier feature not yet in avian
• You want the largest possible pool of community examples and StackOverflow answers
• Your team already knows the rapier API from other engines