-
glam
fast 3D math library for games and graphics
-
bevy
A refreshingly simple data-driven game engine and app framework
-
tobj
A lightweight OBJ loader in the spirit of tinyobjloader
-
bevy_egui
A plugin for Egui integration into Bevy
-
avian3d
An ECS-driven physics engine for the Bevy game engine
-
gilrs
Game Input Library for Rust
-
steamworks
friendly bindings to the steamworks sdk
-
sdl3
Bindings to SDL3, a cross-platform library to abstract the platform-specific details for building applications
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
bevy_tweening
Tweening animation plugin for the Bevy game engine
-
bevy_ecs
Bevy Engine's entity component system
-
bevy_ecs_tilemap
A tilemap rendering plugin for bevy which is more ECS friendly by having an entity per tile
-
bevy_panorbit_camera
A basic pan and orbit camera in Bevy
-
sdl3-sys
Low level Rust bindings for SDL 3
-
cc7800
a subset of C compiler for Atari 7800
-
bevy_asset_loader
Bevy plugin for asset loading
-
bevy_easings
Easing plugin for Bevy
-
rerecast
Rust port of recastnavigation
-
leafwing-input-manager
A powerful, flexible and ergonomic way to manage action-input keybindings for the Bevy game engine
-
raylib
Safe Rust bindings for Raylib
-
tiled
loading maps created by the Tiled editor
-
bevy_ecs_tiled
A Bevy plugin for loading Tiled maps
-
godot
Rust bindings for Godot 4
-
jomini
Low level, performance oriented parser for save and game files from EU4, CK3, HOI4, Vic3, Imperator, and other PDS titles
-
aws-sdk-gamelift
AWS SDK for Amazon GameLift
-
rusty_engine
Learn Rust with a simple, cross-platform, 2D game engine
-
asphalt
Upload and reference Roblox assets in code
-
paneru
A sliding, tiling window manager for MacOS
-
bevy-inspector-egui
Inspector plugin for the bevy game engine
-
bevy_infinite_grid
A 3D infinite grid for Bevy
-
shakmaty
Chess and chess variant rules and operations
-
line_drawing
A collection of line-drawing algorithms for use in graphics and video games
-
ggez
A lightweight game framework for making 2D games with minimum friction, inspired by Love2D
-
screen-13
Vulkan rendering engine in the spirit of QBasic
-
bevy_spritesheet_animation
A Bevy plugin for animating sprites
-
bevy_framepace
Frame pacing and frame limiting for Bevy
-
bevy-tnua
A floating character controller for Bevy
-
wow-adt
Parser for World of Warcraft ADT terrain files with heightmap and texture layer support
-
azalea
A framework for creating Minecraft bots
-
bevy_enhanced_input
Input manager for Bevy, inspired by Unreal Engine Enhanced Input
-
jonmo
ergonomic Bevy-native reactivity powered by FRP signals
-
bevy_tween
Flexible tweening plugin library for Bevy
-
dyon
dynamically typed scripting language
-
avian2d
An ECS-driven physics engine for the Bevy game engine
-
bevy_rand
A plugin to integrate rand for ECS optimised RNG for the Bevy game engine
-
transvoxel
Eric Lengyel's Transvoxel Algorithm
-
bevy-sequential-actions
A Bevy library for executing various actions in a sequence
-
bevy_mod_debugdump
Visualization tools for bevy
-
bevy_rapier2d
2-dimensional physics engine in Rust, official Bevy plugin
-
bevy_brp_mcp
MCP server for Bevy Remote Protocol (BRP) integration
-
godot-bevy
Bridge between Bevy ECS and Godot 4 for Rust-powered game development
-
sfml
Rust binding for sfml
-
bevy_northstar
A Bevy plugin for Hierarchical Pathfinding
-
dora-ssr
The lib for building Dora SSR game as wasm32-wasi that runs on multi-platform Dora SSR engine
-
bevy_flycam
Basic first-person fly camera for the Bevy game engine
-
bevy_async_task
Ergonomic abstractions to async programming in Bevy
-
moonshine-save
Save/Load framework for Bevy
-
virtual_joystick
Bevy virtual Joystick for mobile/web/touch games with Mouse Emulation
-
bevy_pancam
A camera that allows panning by dragging with the mouse
-
bevy_replicon
A server-authoritative replication crate for Bevy
-
bevy-tokio-tasks
integration of a Tokio runtime into a Bevy app for background processing
-
lightyear
Server-client networking library for the Bevy game engine with modular architecture
-
timecat
NNUE-based chess engine that implements the Negamax algorithm and can be integrated into any project as a library. It features move generation, advanced position evaluation through NNUE, and move searching capabilities.
-
bevy_mod_outline
A mesh outlining plugin for Bevy
-
hexx
Hexagonal utilities
-
macaw
An opinionated game math library built on top the excellent glam
-
ascii-forge
A Minimal TUI Ascii Application Engine that simplifies the use of crossterm
-
bevy_materialize
Load, store, and apply type-erased materials in Bevy
-
bevy-persistent
A Bevy helper to easily manage resources that need to persist across game sessions
-
bevy_flowfield_tiles_plugin
FlowField (vector field) pathfinding as a plugin to the Bevy game engine
-
big_space
A floating origin plugin for bevy
-
bevy_svg
Load and draw SVG files in Bevy
-
kish
A high-performance Turkish Draughts (Dama) engine with bitboard representation
-
bevy_save
A framework for saving and loading application state in Bevy
-
agari
A Riichi Mahjong hand calculator and scoring engine
-
fyrox
Feature-rich, easy-to-use, 2D/3D game engine with a scene editor. Like Godot, but in Rust.
-
falling-tetromino-engine
A tetromino stacker engine with goals of being featureful, efficient and elegant
-
bevy_defer
asynchronous runtime for executing async coroutines
-
alchemyst
PCG tool based on Intuicio scripting platform
-
flecs_ecs
Rust API for the C/CPP flecs ECS library https://github.com/SanderMertens/flecs
-
bevy_console
dev console for bevy
-
backgammon
The Rust Backgammon library
-
bladeink
port of inkle's ink, a scripting language for writing interactive narrative
-
seldom_state
Component-based state machine plugin for Bevy. Useful for AI, player state, and other entities that occupy various states.
-
gdextension-api
Godot GDExtension API; used by godot-rust
-
pr4xis
Prove your domain is correct — ontology-driven rule enforcement with category theory, logical composition, and runtime state machines
-
bevy_text_edit
Bevy plugin for input text
-
bevy_trenchbroom
TrenchBroom and ericw-tools integration with Bevy
-
bevy_sprite3d
Bevy Plugin to allow using 2d sprites in a 3d scene
-
bevy_flurx
Allows you to use coroutine in Bevy
-
bevy_ldtk_asset
A Bevy plugin to support LDtk files as assets!
-
throne
Scripting language for game prototyping and story logic
-
bevy-dlc
DLC (downloadable content) management for Bevy games
-
cardpack
Generic Deck of Cards
-
wow-wdt
Parser, validator, and converter for World of Warcraft WDT (World Data Table) files
-
bevy_ios_iap
Bevy Plugin and Swift Package to provide access to iOS native StoreKit2 from inside Bevy Apps
-
bevy-input-sequence
Recognizes and acts on input sequences
-
tiger-lib
used by the tools ck3-tiger, vic3-tiger, and imperator-tiger. This library holds the bulk of the code for them. It can be built either for ck3-tiger with the feature ck3, or for vic3-tiger with the feature vic3…
-
cosync
a single threaded, sequential, parameterized task pool for games
-
bevy_prototype_lyon
Draw 2D shapes and paths in the Bevy game engine
-
crabslab
Slab allocator focused on GPU compute (rust-gpu)
-
dark_iron_ecs
Entity Component System library for Rust
-
godust
CLI tool for Godot Engine template generation
-
caith
A dice roller library supporting many features
-
smaa
post process antialiasing using SMAA
-
cfr
Counterfactual regret minimization solver for two-player zero-sum incomplete-information games
-
edict
Powerful entity-component-system library
-
mireforge-examples
Examples for the mireforge 2D game engine
-
rojo
Enables professional-grade development tools for Roblox developers
-
bevy_ascii_terminal
terminal for rendering ascii in bevy
-
kiran
— AI-native game engine for AGNOS
-
iyes_progress
Bevy plugin to help implement loading states
-
galeon-engine
Core ECS game engine: entities, components, systems, and scheduling
-
polyanya
Polygon Any Angle Pathfinding
-
bevy_smud
2d sdf shape renderer plugin for Bevy
-
farver
color library with easy transformation of colors with less functions
-
spanda
A general-purpose animation library for Rust — tweening, keyframes, timelines, and physics
-
rvpacker-txt-rs-lib
that allows you to generate text files from RPG Maker files
-
hill_vacuum
A bevy-based 2D map editor
-
bevy_editor_cam
A camera controller for editors and CAD
-
oxidized-mc-types
Minecraft game types — BlockPos, SectionPos, Vec3, Aabb, Direction, ResourceLocation, GameType, and more
-
vpin
working with Visual Pinball VPX files
-
bevy_hanabi
Hanabi GPU particle system for the Bevy game engine
-
bevy_trackball
Coherent virtual trackball controller/camera plugin for Bevy
-
rl4burn
Reinforcement learning algorithms for the Burn ML framework
-
impetus
Physics engine — 2D/3D rigid body simulation, collision detection, constraints, and spatial queries for AGNOS
-
rust_pixel
2d pixel-art game engine & rapid prototype tools support terminal, wgpu and web
-
yarnspinner
The friendly tool for writing game dialogue
-
pyri_state
A flexible
bevy_statealternative -
bevy_vello
Render assets and scenes in Bevy with Vello
-
bevy_falling_sand
Falling Sand simulation plugin for Bevy
-
bevy_scriptum
Plugin for Bevy engine that allows you to write some of your game or application logic in a scripting language
-
aeronet
Low-level networking for Bevy
-
emergent
Toolset for producing emergent gameplay for games written in Rust
-
bevy_debug_grid
A bevy plugin for creating grids, for debugging purposes
-
bevy_auto_plugin
Procedural attribute macros for Bevy apps that reduce boilerplate by automatically registering components, resources, events, states, and systems in your plugin's build function
-
playdate
High-level Playdate API
-
bevy_material_ui
Material Design 3 UI components for Bevy game engine
-
bevy_common_assets
Bevy plugin adding support for loading your own asset types from common file formats such as json and yaml
-
bevy_pkv
Persistent key value store for apps/games
-
modde-cli
CLI interface for modde
-
lazychess
A fast, memory-efficient chess engine library for Rust
-
bevy_stdb
A Bevy-native integration for SpacetimeDB with table messages, subscriptions, and reconnect support
-
moonshine-behavior
Minimalistic state machine for Bevy game engine
-
bevy_aseprite_ultra
A Bevy plugin for directly loading spritesheets and animations from aseprite binary files with hot reloading support
-
thor
Git worktree dashboard with AI agent coordination
-
weirdboi_tween
Relationship based component value tweening for Bevy projects
-
pistoncore-glutin_window
A Piston window back-end using the Glutin library
-
bevy_ggrs
Bevy plugin for the GGRS P2P rollback networking library
-
bevy_symbios_multiuser
Multi-user networking for Bevy via ATProto auth with WebRTC p2p messaging
-
archetype_ecs
Archetype ECS - High-performance Entity Component System with parallel execution
-
manasight-parser
MTG Arena log file parser — reads Player.log and emits typed game events
-
bevy-steamworks
A Bevy plugin for integrating with the Steamworks SDK
-
bevy_image_font
Render pixel fonts from PNGs in Bevy
-
bevy_basic_portals
A portal plugin for Bevy game engine
-
landmass
A navigation system for video game characters to walk around levels
-
halbu
Diablo II save file parsing library
-
bevy_vox_scene
A Bevy engine plugin for loading Magica Voxel world files and render materials directly in Bevy as a scene graph
-
gdt-cpus
Game Developer's Toolkit for CPU Management
-
bevy_polyline
Polyline Rendering for Bevy
-
smol-rgb
A smol library for (s)Rgb color handling
-
spades
A popular four person card game implemented in Rust
-
licheszter
An API wrapper for the Lichess API
-
pybevy
Python Real-Time Engine Built on Bevy
-
world_dispatcher
System part of a full ECS, along with a fast dispatcher and world container
-
riichienv-core
Japanese Mahjong (Riichi) game engine with MJAI protocol support
-
geese
Dead-simple game event system for Rust
-
bevy_window_manager
Bevy plugin for primary window restoration and multi-monitor support
-
bevy_ahoy
A fun 3D Kinematic Character Controller for Bevy + Avian + BEI
-
lotus_engine
Lotus is a game engine with the main focus of being easy-to-use and straight forward on developing 2D games
-
bevy_life
Generic and dynamic cellular automaton lib for bevy
-
bevy-trait-query
trait queries for the bevy game engine
-
laura_core
A fast and efficient move generator for chess engines
-
bevy_behave
A behaviour tree plugin for bevy with dynamic spawning
-
bevy-discord
A bevy plugin for sending and receiving discord messages
-
bevy_ecs_ldtk
An ECS-friendly ldtk plugin for bevy
-
bevy_fsm
Observer-driven finite state machine framework for Bevy ECS with variant-specific events and flexible validation
-
bevy_voxel_world
A voxel world plugin for Bevy
-
catgirl-engine
A game engine for cool moddability and procedurally generated data
-
keyframe
animation in Rust
-
nnsdk
Cleanroom reverse-engineered bindings for nnsdk (Nintendo Switch SDK)
-
bevy_skein
Process glTF extras when spawning Scenes to insert Components using Reflection, such as when using Blender as an editor
-
bevy_enoki
2D Particle system plugin, that works well on wasm and mobile
-
bevy-async-ecs
Asynchronous interface for Bevy ECS
-
localgpt-bridge-discord
Discord bridge for LocalGPT
-
bevy_lunex
Blazingly fast retained UI layout engine for Bevy ECS
-
bevy_slippy_tiles
slippy tile fetching functionality in the Bevy game engine
-
bevy_serialport
Async serial port plugin for Bevy game engine with enhanced error handling and convenience APIs
-
bevy_obj
Wavefront OBJ mesh asset loader plugin for the Bevy engine
-
bevy_archie
A comprehensive game controller support module for Bevy
-
bevy_hookup_core
The core library of the bevy_hookup library
-
ndm
Parse standard polyhedral dice notation
-
amaze
A maze generator
-
boxdd
Safe, ergonomic Rust bindings for Box2D v3
-
bevy_mod_physx
PhysX plugin for Bevy
-
bevy_sprinkles_editor
GPU particle system editor for Bevy
-
chess
fast chess move generator. It has a very good set of documentation, so you should take advantage of that. It (now) generates all lookup tabels with a build.rs file, which means that…
-
bevy_ui_text_input
Bevy UI text input plugin
-
bvh-arena
A bounding-volume hierarchy for in-game broad-phase collision detection
-
oktree
Fast octree implementation
-
littlewing
A chess engine rated at 2050+ ELO, compatible with both UCI and XBoard protocols, with a nice CLI, and a documented library
-
luau0-src
Minimal sources of Luau and logic to build them
-
pixels-graphics-lib
pixel graphics and GUI library
-
bevy_vector_shapes
rendering vector shapes using the Bevy game engine
-
bevy_mod_index
Allows using indexes to efficiently query for components by their values in the game engine Bevy
-
bevy_minibuffer
A gamedev console inspired by classic Unix text editors
-
nalimov
Zero-dependency Nalimov endgame tablebase prober — pure Rust, 3–6 pieces, thread-safe
-
signal-fish-client
Transport-agnostic Rust client for the Signal Fish multiplayer signaling protocol
-
bevy_third_person_camera
A third person camera written for Bevy
-
bevy_quinnet
Bevy plugin for Client/Server multiplayer games using QUIC
-
cao-lang
The back-end of cao-lang, a node based visual scripting language
-
bevy_stl
STL loader for bevy, based on stl_io
-
bevy_mod_scripting
Multi language scripting in Bevy
-
caption-compiler
Compiles and describes Valve's closed caption files
-
hobo
frontend framework
-
sparsey
Entity Component System based on sparse sets
-
bevy_2d_menu_mask_transition
A Bevy plugin for creating smooth menu transitions with customizable masks
-
egui_ratatui
WASM ratatui with egui works with bevy and macroquad and eframe
-
ctrlassist
Controller Assist for gaming on Linux
-
tetra
2D game framework written in Rust
-
bevy_procedural_meshes
Procedural Meshes for the Bevy game engine
-
coord_2d
A general purpose 2d coordinate
-
chessgen
Chess moves generator
-
voxquant
A program to convert triangle meshes to voxels
-
pyxel-engine
Core engine for Pyxel, a retro game engine for Python
-
bevy_eulerian_fluid
An eularian fluid simulation plugin for Bevy
-
micro_banimate
Easily manage complex Bevy 2D sprite animations
-
casc-cli
CLI tool for extracting files from World of Warcraft CASC archives
-
vk-graph
A high-performance Vulkan driver with automatic resource management and execution
-
univis_ui_engine
Layout and render engine for Univis UI
-
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
spooky_chess
Chess board game engine
-
hapi-rs
Rust bindings to Houdini Engine API
-
bevy-settings-lib
A flexible settings management library for Bevy with async saving, multiple formats, and built‑in validation
-
bevy_feronia
Foliage/grass scattering tools and wind simulation shaders/materials that prioritize visual fidelity/artistic freedom, a declarative api and modularity
-
russimp
Assimp bindings for rust
-
bevy_mod_async
Ergonomic async tasks plugin for the Bevy game engine
-
bevy-yoleck
Your Own Level Editor Creation Kit
-
bgi
A modern Rust port of the Borland Graphics Interface (BGI) with extensible backends
-
bevy_ratatui_camera
A bevy plugin for rendering your bevy app to the terminal using ratatui
-
raster_font
A format for authoring and using image-backed fonts
-
wow-m2
Parser, validator, and converter for World of Warcraft M2 model files with animation support
-
bevy_transform_interpolation
Transform interpolation for fixed timesteps for the Bevy game engine
-
herdingcats
Deterministic rule orchestration for ambiguity-free turn-based games
-
fenex
parsing and handling FEN and algebraic chess notations
-
bevy-mod-indigauge
Understand your users. Grow your game. Track events, session health, and user sentiment with zero fuss
-
pyri_tooltip
Powerful tooltips for Bevy
-
oxyde
AI Agent SDK for Game NPCs
-
dfhack-remote
Interacting with the Dwarf Fortress remote API exposed by DFHack
-
moonshine-kind
type safety solution for Bevy
-
uxie
Data fetching library for Pokemon Gen 4 romhacking - map headers, C parsing, and more
-
bevy_fact_rule_event
Fact-Rule-Event system for Bevy engine
-
ghx_proc_gen
2D & 3D procedural generation with WFC/Model synthesis
-
necs
An ECS implementation, primarily serving as a learning project
-
bevy_gameplay_tag
A flexible gameplay tag system for Bevy, inspired by Unreal Engine's Gameplay Tags
-
bevy_pipe_affect
Write systems as pure functions
-
magpie
High-performance Othello library built with bitboards
-
bevy_simple_tilemap
Refreshingly simple tilemap implementation for Bevy Engine
-
magma_ecs
Entity-Component-System for the Magma3D game engine
-
bevy_turborand
A plugin to enable ECS optimised random number generation for the Bevy game engine
-
bevy_mod_xr
semi generic Xr Api for Community Driven XR in Bevy
-
gamepads
access information about connected gamepads
-
bevy_live_wallpaper
A Bevy plugin to create live wallpapers
-
pak
data pak format for games
-
beet_flow
An ECS control flow library
-
genshin-calc-data
Genshin Impact game data for genshin-calc
-
gba
‘raw’ style GBA development. If you want a ‘managed’ experience, try the
agbcrate instead. -
bevy_cef
Bevy CEF integration for web rendering
-
chunky-bevy
efficient chunk management system for Bevy
-
boon-deadlock
Boon is a Deadlock demo / replay file parser
-
bevy_titan
Bevy plugin for spritesheet manifest loading
-
dymod
A macro to allow hotswapping code for a module in debug mode, but statically linking it safely in release mode
-
myth-engine
A developer-friendly, high-performance 3D rendering engine written in Rust
-
physis
reading and writing FFXIV data
-
wf-market
client library for the warframe.market API
-
hnefatafl-copenhagen
Copenhagen Hnefatafl client, engine, server and artificial intelligence
-
rinklecate
inklecate — compile and play Ink stories from the command line
-
bevy_mqtt
A robust, secure MQTT client plugin for Bevy game engine with comprehensive error handling and performance optimizations
-
meshtext
Generate vertex-vertex meshes from text
-
bevy_simple_text_input
Bevy plugin for a simple single-line text input widget
-
dreamwell-gpu
Dreamwell shared GPU infrastructure — wgpu pipelines, compute, ray tracing, mesh shaders, particles, sprites, procedural generation
-
rx_bevy
Reactive Extensions for the Bevy game engine
-
bevy_pixels
Bevy plugin that uses Pixels (a tiny pixel buffer) for rendering
-
skesis
A high-performance Entity Component System with anchor+delta change detection, relationships, and raw byte serialization
-
bevy-histrion-packer
A Bevy Plugin to pack all your game assets into a single common PAK like file format
-
bevy_match3
A logic library for quickly adding a match-3 system to any bevy project
-
wgm
A fast and simple math library for game and graphics development
-
haalka
ergonomic reactive Bevy UI library powered by FRP signals
-
bevy_tui_texture
A Bevy plugin for rendering terminal-style UIs using ratatui and WGPU
-
ply-engine
The most powerful app engine made entirely in Rust
-
voronoi_mosaic
Bevy mesh generation from Delaunay Triangulation and Voronoi Tessellation
-
tiled_map_web_viewer
A Tiled map viewer with WASM support for web deployment
-
ckc-rs
Poker hand evaluation library
-
egor
A dead simple 2D graphics engine
-
chron
A game loop with a fixed timestep
-
il2cpp-bridge-rs
Unity IL2CPP runtime introspection — resolve classes, invoke methods, and interact with the IL2CPP VM at runtime
-
stackr-rs
A stack-based interpreter to be embedded in your application. Heavily inspired by Forth.
-
plumesplat
Advanced terrain splatting for Bevy with support for 256+ materials using texture arrays
-
ltk_mod_project
Types and helpers for League Toolkit mod project definitions
-
neurodoom
Deterministic no_std Doom engine with semantic and depth perception buffers for AI
-
renderling
User-friendly real-time rendering. 🍖
-
pons
Rust package for contract bridge
-
montyformat
Chess implementation & compressed data formats for Monty
-
steam-vent-proto-tf2
Protobuf structs used by the Steam client protocol
-
gdext_coroutines
Run Rust Async functions and Coroutines in Godot 4.4+ (through GDExtension), inspired on Unity's Coroutines design
-
rustpak
CLI tool for reading and writing GoldSrc .pak archive files
-
finite_light_bevy
Bevy plugin for real-time special-relativistic rendering. Part of the Finite Light project.
-
uvm_detect
Unity project detection and version extraction library
-
mun_abi
Rust wrapper for the Mun ABI
-
bevy_symbios
Bevy integration for the Symbios L-System ecosystem
-
hlm-wad-tools
Tools for extracting and repacking Hotline Miami's .wad archive files
-
scryfall
A wrapper around the scryfall magic the gathering api
-
bevy_state_ui
UI library for rendering a UI from a given state
-
bevy_health_bar3d
Health bar for bevy implemented as a billboard shader
-
godot-gis
Godot GDExtension for saving, loading, and manipulating GIS data
-
blue_engine
General-Purpose, Easy-to-use, Fast, and Portable graphics engine
-
bevy_map_animation
Animation and sprite types for bevy_map_editor
-
fyrox-math
Math utils for the Fyrox engine
-
sprites7800
a companion tool of cc7800 generating C sprites/tiles code
-
bevy_light_2d
General purpose 2d lighting for the Bevy game engine
-
raylib-wasm
raylib native/wasm bindings
-
ascending_graphics
A graphical rendering library for 2D, using wgpu and winit
-
blockpedia
A comprehensive Rust library for Minecraft block data with advanced color analysis and palette generation
-
double_dot_state
State management crate built for the Bevy game engine
-
vulk
Vulkan bindings for Rust, except only the bleeding edge features
-
spatial_hash_3d
3D spatial hash grid implementation optimized for speed. What it does/why you'd want one: https://www.youtube.com/watch?v=sx4IIQL0x7c
-
rx_core
Runtime Agnostic Reactive Extensions
-
chess-tui
Play chess from your terminal 🦀
-
bevy_hui
pseudo Html templating ui crate for the bevy-engine
-
game-loop
that implements a frame-rate-independent game loop
-
firefly_cli
CLI tool for working with Firefly Zero
-
bevy_rl
Build environments for reinforcement learning with bevy
-
suon_lua
Lua scripting integration for the Suon MMORPG framework
-
bevy_config_file
A Bevy plugin for loading configuration from YAML, JSON, or RON files with environment variable overrides
-
bevy_debugger_mcp
AI-assisted debugging for Bevy games through Claude Code using Model Context Protocol
-
ludusavi
Game save backup tool
-
bevy_log_events
A Bevy plugin that helps to log events
-
rpgx
Lightweight, modular, and extensible RPG game engine 2D, designed for flexibility, portability, and ease of use
-
bevy_flicker
An easy to use event-based system to apply brief overlays to sprites and meshes
-
xash3d-ffi
Raw FFI bindings to Xash3D FWGS engine
-
crossflow
Reactive programming and workflow engine in bevy
-
bevy_edge_detection_outline
Edge detection outline post-processing plugin for Bevy — Sobel, Roberts Cross, and PixelArt operators with silhouette/crease priority, per-entity channel mask, depth/normal/color edge sources (WGSL shader)
-
plasma-prp
Read, write, inspect, and manipulate Plasma engine PRP files used by Myst Online: Uru Live
-
game-networking-sockets
Rust abstraction for Valve GameNetworkingSockets library
-
bevy_args
bevy plugin to parse command line arguments and URL query parameters
-
game_features
Various helpful constructs for game development. See the github repository for detailed instructions.
-
bevy-color-palettes
Color palettes for Bevy and egui, with macros for compile-time palette definitions, based on weirdboi_bevy_colour
-
extendable-assets
Asset framework for graphics and games
-
bevy_file_dialog
File system dialogs for loading and saving files using the Bevy game engine
-
checs
An Entity-Component-System library
-
wgpu_render_manager
Cached Render/Compute Manager for wgpu (pipelines + bind groups + procedural textures automated)
-
bevy_psx
A Bevy plugin that provides authentic PlayStation 1 (PSX) style rendering capabilities, including low-resolution rendering, vertex snapping, and palette quantization
-
mlua-pkg
Composable Lua module loader for mlua
-
shade
graphics library
-
russimp-ng
Assimp bindings for rust
-
limnus-app
Application management
-
edges
getting the edges of objects in images with transparency
-
bevy_xr_utils
utils for bevy_mod_xr and bevy_mod_openxr
-
bevy_persistence_database
A persistence and database integration solution for the Bevy game engine
-
bevy_mesh_terrain
ergonomic heightmap terrain plugin for Bevy game engine
-
matter-js-rs
port of Matter.js, the 2D rigid body physics engine
-
hex2d
Helper library for working with 2d hex-grid maps
-
bevy_modern_pixel_camera
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
chill_bevy_console
A configurable developer console plugin for Bevy games
-
bevy_serde_lens
Blazingly fast, schema based human-readable serialization crate for the bevy engine
-
bevy_lookup_curve
Editable lookup curve for Bevy
-
avian_pickup
A plugin for implementing picking up dynamic rigid bodies in Avian physics for the Bevy engine. Modeled after Half Life 2's gravity gun.
-
tiqtak
Checkers engine
-
petro-meg
Reader and Writer for Petroglyph MEGA file format
-
glam_det
fast 3D math library for games and graphics
-
univis_ui
A high-performance, SDF-based hybrid world-space UI framework for the Bevy game engine
-
bevy_ui_anchor
A small bevy plugin for anchoring UI elements to specific points or entities in the world
-
dbsdk-rs
API for creating Rust games for the DreamBox fantasy console
-
map_scatter
Rule-based object scattering library with field-graph evaluation and sampling
-
poker
speedy poker hand evaluation
-
bevy_entity_ptr
Ergonomic smart-pointer-like access to Bevy entities (immutable only)
-
bevy_debug_log
Allows viewing tracing debug log output inside the bevy app using vanilla bevy_ui
-
hotline-rs
A high-performance, hot-reload graphics engine
-
bevy_fast_light
2D lighting for Bevy focused on performance over features
-
bevy_firefly
2d lighting crate for the Bevy game engine
-
bevy_tween_helpers
Optional, additional utilities for the bevy_tween crate
-
dokearley
Earley parser + DSL grammar language for game devs
-
hoomd-bevy
Use Bevy to render hoomd-rs simulations in real time
-
bevy_silk
Cloth physics implementation in bevy
-
iyes_perf_ui
Customizable Performance/Debug Overlay for Bevy UI
-
blf_lib
Multi-purpose Blam-File library
-
telic
Engine-agnostic game AI framework: command trees, utility scoring, coordinated assignment, and TrueSkill evaluation
-
cloudiful-bevy-localization
Reusable Bevy localization runtime built around app-provided static registries
-
bevy_descendant_collector
Bevy crate to collect named entities into a single component
-
prime-random
Seeded randomness — Mulberry32 RNG, Poisson disk, weighted choice
-
hyperion_ec_no_s
A dense ECS without the S
-
fyrox-template
Command line interface for project template generator for Fyrox engine
-
warcraft-rs
Unified CLI for World of Warcraft file format parsing, conversion, and validation
-
reverie-engine
A toy game engine
-
bevy_lit
A lighting 2d library for Bevy
-
bevy_ui_actions
Action-driven UI toolkit for Bevy — clicks, drag-drop, tooltips, tabs, scroll views, modals, dialogue system, 3D viewports
-
bevy_npc
Proto-driven NPC definitions for Bevy games — compiles npcdb.proto into typed Rust structs with a searchable registry
-
bevy_normal_material
normal material for Bevy
-
vecmath
type agnostic library for vector math designed for reexporting
-
bevy_smooth_pixel_camera
Smooth pixel-perfect camera for Bevy
-
gantz
An environment for creative systems
-
bevy_retro_shaders
Retro post-processing shaders for Bevy - CRT effects, scanlines, and glitch effects
-
oxiphysics-rigid
Rigid body dynamics for the OxiPhysics engine
-
rsaber_pcvr
rsaber
-
beet_dom
dom rendering and interaction
-
bevy_screen_diagnostics
Bevy plugin for displaying diagnostics on screen
-
bulls-and-cows
A framework for building bulls-and-cows games (1A2B) for any data type
-
bevy-patch
Generate bevy patch lists
-
Horizon-Network-Common
Shared network types and protocols for Horizon ecosystem (Horizon, Atlas, Maestro)
-
bonsai-cli
CLI for the bonsai 2D game framework
-
arcane-cli
CLI for Arcane - agent-native 2D game engine (dev server, testing, project scaffolding)
-
noisy_bevy
Procedural noise primitives for Bevy
-
crust-engine
A Scratch-inspired game development tool with its own text-based programming language
-
huozi
typography engine for CJK languages, especially designed for game rich-text
-
procmod-overlay
Game overlay rendering with transparent click-through windows
-
bevy_axon
Bevy Axon
-
bevy_ui_bits
A tiny and opinionated collection of UI components for Bevy
-
bevy_cobweb
Reactivity primitives for Bevy
-
vera-effects
VERA (Verified Effect-Rule Architecture) — generic trace, rule output, and reaction types for building verifiable game loops where every state mutation is inspectable and testable
-
taikyokushogi
Taikyoku Shogi engine — the largest known shogi variant (36x36 board, 804 pieces, 209 piece types)
-
riichi_hand
A collection of utilities for working with Riichi Mahjong player hands
-
thin-engine
A thin engine between glium, winit, glium-types and winit-input-map with some extra helper functions
-
bevy-earcutr
earcutr + Bevy
-
tyche
Dice rolling and dice expression (with a syntax similar to FoundryVTT) parsing library
-
nano9
A Pico-8 compatibility layer for Bevy
-
unity-asset
A comprehensive Rust library for parsing Unity asset files (YAML and binary formats)
-
aip-sci
Affective Interaction Programming - 情感交互编程
-
bevy_auto_nav_viz
A Bevy plugin that draws a visualization of the auto directional navigation system in Bevy's UI Framework
-
sdec-schema
Replication schema and field codec definitions for the sdec codec
-
gba_save
Tools for interacting with backup media on Game Boy Advance cartridges
-
bevy-sensor
Bevy library for capturing multi-view images of 3D OBJ models (YCB dataset) for sensor simulation
-
brawllib_rs
Brawl character file parser, based on brawlbox/brawllib
-
shrev
Event channel, meant to be used with
specs -
massive_game_server_admin_tools
Administrative CLI utilities for massive_game_server operations
-
bevy_ios_gamecenter
Bevy Plugin and Swift Package to provide access to iOS native GameKit (Gamecenter) from inside Bevy Apps
-
rshogi-core
A high-performance shogi engine core library with NNUE evaluation
-
bevy_image_export
Bevy plugin for rendering image sequences
-
raasta
— navigation and pathfinding engine for AGNOS
-
bevy-axes-gizmo
A tiny Bevy plugin for an axes gizmo
-
timeline_rs
timeline library for Rust
-
jackdaw_node_graph
Generic node-graph editor widget for the Jackdaw editor
-
ayatsuri
— Rust-native Neovim plugin for the blnvim-ng distribution
-
bevy_screen_diags
An on-screen FPS display for bevyengine.org
-
bevy_bsml
A UI library to compose UI elements using simple markup language, inspired by svelte and tailwindcss
-
rrplug
framework for R2Northstar plugins
-
rumenx-chess
A high-performance chess engine and REST API server written in Rust
-
symbolic-unreal
Parsing and processing utilities for Unreal Engine 4 crash files
-
archipelago_rs
client for the archipelago.gg multiworld randomizer
-
bevy_html_tailwind
Use HTML + Tailwind CSS to generate bevy ui trees
-
bevy_basisu_loader
lightweight, cross-platform KTX2 Basis Universal texture loader for Bevy
-
bevy_parallaxium
A Bevy plugin for creating a parallax effect
-
ldtk_rust
LDtk 2D level editor to build games in Rust
-
shen-nbt5
Just A FASSST NBT parser/writer
-
boulderdash
clone
-
jugar
WASM-native universal game engine - entry point
-
structecs
A structural data access framework. Type-safe extraction from nested structures with Arc-based smart pointers.
-
shuftlib
A generic library for card games and related topics
-
pix-engine
A cross-platform graphics/UI engine framework for simple games, visualizations, and graphics demos
-
rmv-bevy-testing-tools
Write simple tests for bevy systems, using rstest, insta, and speculoos
-
rustymines
A mine sweeping game engine with optional duds
-
rs2io
Types and utilities for processing io with a design heavily focused around the custom protocols used by the popular MMORPG Runescape
-
gametools
Toolkit for game-building in Rust: cards, dice, dominos, spinners, refillable pools, and ordering helpers
-
steamworks-sys
raw bindings to the steamworks sdk
-
bevy-volumetric-clouds
A plugin for Bevy that renders clouds using raymarching
-
bevy-flair-html-extension
Extension for bevy_flair which adds basic HTML-like syntax with hot-reloading
-
bevy-panic-handler
A Bevy plugin that creates a popup message and logs to error on panic
-
bosh-rs
A highly customizable physics engine for the game Line Rider
-
tatami-dungeon
A roguelike dungeon generation algorithm
-
anput
Scriptable Entity-Component-System (powered by Intuicio)
-
bevior_tree
Behavior tree plugin for Bevy
-
bevy_bitmap_text
Glyph-as-Entity dynamic atlas text rendering for Bevy
-
egui-minesweeper
A minesweeper game library for egui
-
actuate
A reactive user-interface framework
-
cala
Make portable apps and video games in Rust!
-
sfbinpack
read Stockfish Binpacks
-
ergoap
GOAP (Goal Oriented Action Planning) system with focus on ergonomics and ease-of-use
-
rustorio-engine
first game written and played entirely in Rust's type system. Not just do you play by writing Rust code, the rules of the game are enforced by the Rust compiler! If you can write the…
-
bevy_simple_screen_boxing
but small, crate that aims to make Letter/Pillar Boxing in Bevy easy
-
resonite
Resonite's API in rust
-
issun
A mini game engine for logic-focused games - Build games in ISSUN (一寸) of time
-
roblox-studio-utils
Cross-platform library for interacting with Roblox Studio
-
valheim-mod-manager
Mod manager for Valheim game
-
pinmame-nvram
handling PinMAME NVRAM files
-
pmd_wan
that can read wan file, a sprite format used in pokemon mystery dungeon games
-
bevy_mod_skinned_aabb
A Bevy plugin that automatically calculates AABBs for skinned meshes
-
bevy_fps_controller
Bevy plugin that adds a Source engine inspired FPS movement controller
-
unity-native-plugin
Unity Native Plugin API for Rust
-
firefly-rust
Rust SDK for making Firefly Zero games
-
mctext
Minecraft text formatting, parsing, and rendering
-
bevy_cronjob
helper to run cronjobs (at repeated schedule) in Bevy
-
cranium
A fast, modular, no_std-friendly, batteries-included library for Game AI written in Rust
-
ecsx
Entity Component System eXtended
-
firewheel-nodes
Official factory nodes for the Firewheel audio engine
-
rbxsync
Declaratively manage Roblox game passes, badges, and developer products
-
allegro_util
Rust Allegro 5 wrapper utilities
-
dcso3
Minimal Rust binding to the DCS lua api
-
bevy_cursor_kit
A Bevy plugin for working with cursors
-
bevy_mod_rounded_box
A rounded box shape for Bevy
-
bevy_framebuffer
Bevy framebuffer rendering using the
pixelsandsoftbufferbackends -
v-shield
Platform layer + sync primitives for Ry-Dit game engine
-
zero_ecs
Entity Component System (ECS), using only zero-cost abstractions
-
swamp-examples
Examples for the swamp 2D game engine
-
aluminium
vulkan-based graphics engine
-
portal2-sdk
SDK for Portal 2 modding and plugin development
-
makara
A Bevy UI simplifier that make it easy to build GUI app with bevy engine
-
anvilkit
game engine — a modular, ECS-based game engine built with Rust
-
terra-plr
Terraria player parser
-
dodgy_2d
ORCA, a local collision avoidance algorithm for 2D
-
aseprite-io
Read and write Aseprite .ase/.aseprite files
-
gdlib
editing Geometry Dash savefiles
-
lf-gfx
A collection of utilities that we use
-
minacalc-rs
Safe Rust wrapper for MinaCalc (Etterna difficulty calculator v515)
-
bevy_gltf_kun
Bevy glTF plugin using gltf_kun
-
procedural_modelling
A framework-agnostic Procedural Modelling crate
-
gltf_opt
Optimize glb file by resizing textures and adjusting pivot points
-
bevy_window_title_diagnostics
Logs Bevy diagnostics into the primary window title
-
devotee
Visualization engine
-
bevy_quick_response
A Bevy plugin for quick responsive behaviors
-
ghx_grid
2D & 3D grid structures & utilities
-
bolt-quadtree
High-performance loose quadtree for 2D collision queries
-
forte
A low-overhead thread-pool with support for non-static async closures
-
haloforge-plugin-api
Plugin API for HaloForge — traits and types for building native HaloForge plugins
-
bevy_fontmesh
focused Bevy plugin for generating 3D text meshes from fonts
-
charmed-harmonica
Physics-based animation tools: spring oscillator and projectile motion
-
pr4xis-cli
Praxis chatbot CLI — axiomatic intelligence via ontology
-
chunksplitter
Split and merge Minecraft Bedrock Edition worlds for version control
-
immediate_stats
Game stats that reset every frame, inspired by immediate mode GUI
-
bevy_event_bus
A Bevy plugin that connects Bevy's event system to external message brokers like Kafka
-
bevy-intl
A custom Bevy plugin for adding traductions
-
bevy_locomotion
A first-person character controller for Bevy and Avian3d
-
zero-alloc-sudoku
Zero-allocation, sub-microsecond Sudoku solver with 9-bit bitboard constraint propagation and MRV backtracking
-
tiles_tools
High-performance tile-based game development toolkit with comprehensive coordinate systems (hexagonal, square, triangular, isometric), pathfinding, ECS integration, and grid management
-
startail
3D Satellite Tracking System using Bevy
-
bevy_firework
CPU-driven, batch-rendered particle system for the Bevy game engine
-
gdcli
Agent-friendly CLI for Godot 4
-
bevy_mod_imgui
A Dear ImGui integration for the Bevy game engine
-
bevy_text_gizmos
Text gizmo implementation for Bevy using stroke fonts
-
buffer-graphics-lib
graphics library for buffers
-
extol_sprite_layer_fork
Explicitly-defined sprite layers for Bevy, including automatic y-sorting
-
rpkg-rs
Parse Glacier ResourcePackage (rpkg) files, allowing access to the resources stored within
-
bms-table
BMS (Be-Music Source) difficulty table parser & fetcher
-
bevy_app
core App functionality for Bevy Engine
-
bevy_local_commands
local shell commands for the Bevy game engine
-
uika
Rust bindings for Unreal Engine 5.7+
-
bevy_pixcam
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
bevy_foliage_tool
A configurable foliage painting system using perlin noise, grayscale maps, and chunked visibility
-
vic3-tiger
Validator that checks Victoria 3 user mod files for mistakes and warns about them. For example: missing localizations, or using a state trigger on a country. Victoria 3 is a grand strategy…
-
archetype_asset
Fast, modular asset system with spatial preloading
-
pyxel-wrapper
Python extension module for Pyxel, a retro game engine for Python
-
rbp-gameroom
Async game coordinator, player implementations, and hand history
-
maple
A 3D game engine
-
wolfrpg-map-parser
Parser for Wolf RPG Editor map files
-
plurimus
set of components and systems to make it easier to build terminal UIs with bevy_ratatui
-
bevy_koto
Koto support for Bevy
-
terraria-world
Terraria world file (.wld) parser library
-
puppetmaster
input handling for writing games
-
bevy_query_ext
Extensions for Bevy's queries
-
fyrox-graph
Graph management crate for the Fyrox engine
-
bevy-clipmap
Render huge 3D worlds using Bevy!
-
bevy_2d_screen_space_lightmaps
Lighting plugin for 2D games made in the Bevy engine. This plugin uses the screen space lightmaps technique
-
bevy_serial
Serial Port Communication Plugin for Bevy
-
schnapsen-rs
Schnapsen implementation in Rust
-
xript-runtime
Rust runtime for xript. Sandboxed JavaScript execution via QuickJS.
-
cinnog
Data layer and helper methods for static site generation with Leptos
-
bevy_metalfx
Bevy plugin for Apple MetalFX upscaling and frame interpolation
-
moonshine-tag
Cheap, fast, mostly unique identifiers designed for Bevy
-
open-timeline-games
OpenTimeline games
-
bitmapfont-creator
A CLI tool to create bitmap fonts for Phaser games
-
bevy-paperdoll
Bevy plugin for 2D paper doll
-
bevy-egui-kbgp
Better keyboard and gamepad story for egui in Bevy
-
bevy_scripting_rune
Script bevy games using rune
-
bevy_prefs_lite
preferences system for Bevy
-
nfp
No Fit Polygon
-
gdman
A CLI application for managing versions of Godot
-
lightyear_examples_common
Common harness for the lightyear examples
-
bevy_simple_screenshot
A plug-and-play screenshot library for Bevy 0.17+ with ring-buffered capture and automatic saving
-
tiled_parse
Tiled tmx parser with nom
-
legion
High performance entity component system (ECS) library
-
micro_bevy_world_utils
Handy, reusable utilities for working with direct world access in a Bevy exclusive system
-
hoplite
A creative coding framework for Rust that gets out of your way
-
basis-universal
Bindings for the basis-universal Supercompressed GPU Texture Codec by Binomial
-
rltk
A CP437/ASCII terminal library and helpers to make creating roguelike games in Rust easy. Similar to libtcod, but aiming to be Rust-native.
-
bevy_keyboard_shortcuts
Keyboard shortcut system for Bevy applications
-
bevy_resolution
An easy to use convienence crate for dealing with resolutions in Bevy
-
bevy_eventwork
Event based networking library for Bevy
-
bevy_steam_audio
Integration between bevy_seedling and Steam Audio over audionimbus
-
brood
A fast and flexible entity component system library
-
common_x
common
-
bevy_interleave
bevy support for e2e packed to planar bind groups
-
bevy_exponential_height_fog
Standalone exponential height fog extension for Bevy volumetric fog
-
jugar-ui
Responsive UI system with anchor-based layout
-
bevy_debug_panel
show debug info to panel
-
haggis
A 3D rendering and simulation engine built in Rust using wgpu for graphics rendering and winit for windowing, supporting both CPU and GPU-based simulations with real-time visualization
-
bevy_eidolon
Generic instanced material for the bevy game engine
-
bevy_mod_lookat
A microplugin for Bevy, that allows adding a component to an entity, that makes it target either an entity, or a position
-
breeze
A wrapper around Bevy for easier game development
-
stringid
Lightweight system to manage identifier as human readable string and unique number
-
bevy_mod_aseprite
A plugin for using Aseprite animations in Bevy
-
bevy_sun_move
A Bevy plugin for simulating realistic sun movement
-
frame_counter
frame counter and limiter
-
arboriter-mcts
A Monte Carlo Tree Search implementation built on the arboriter tree traversal primitive
-
sevenx_engine
Engine de jogos 2D/3D completa com suporte Android, física, áudio, partículas, tilemap, UI, eventos e sistema 3D avançado com PBR
-
reaction
Universal low-latency input handling for game engines
-
uesave_cli
Unreal Engine save file (GVAS) reading/writing
-
aeronet_websocket
WebSocket IO layer implementation for
aeronet -
flecs
Rust bindings for the Flecs Entity Component System
-
bevy_mesh_outline
A Bevy plugin for rendering 3d mesh outlines
-
bevy_flair
Bevy UI styling using CSS
-
acc_shared_memory_rs
reading Assetto Corsa Competizione shared memory
-
bevy_marching_cubes
A small Bevy plugin that generates meshes from signed-distance-field (SDF) using the Marching Cubes algorithm
-
goud-engine
GoudEngine — build 2D and 3D games in Rust with zero FFI overhead
-
bevy_monitors
A reactive(ish) crate for the bevy engine
-
ngdp-client
Command-line interface for Blizzard's NGDP with product queries, certificate management, and key operations
-
kazam-battle
Battle state tracking and domain types for Pokemon Showdown (experimental)
-
falling
game about falling
-
thdmaker
A comprehensive 3D file format library supporting AMF, STL, 3MF and other 3D manufacturing formats
-
bevy_rapier3d
3-dimensional physics engine in Rust, official Bevy plugin
-
foil_rs_bevy
Bevy UI frontend for FoilRs (interactive airfoil playground)
-
ry-config
Zero-dependency config parser for .rydit files — entities, levels, checkpoints
-
crystal-api
Crystal API is a unified GPU API's wrapper
-
pigment64
handling conversion between N64 texture formats and modern image formats
-
bevy_ai_editor
A remote AI level editor plugin for Bevy engine, enabling Python-based scene manipulation for AI agents
-
stacker-engine
Core stacker game engine
-
fast-tak
abstract strategy board game Tak
-
qbsp
parsing and operating with Quake 1, 2, and GoldSrc BSP files
-
bevy_spawnable
tiny spawn utility for Bevy, to encapsulate spawn logic
-
bevy_ehttp
A ehttp client plugin for Bevy
-
bevy_ingame_clock
An in-game clock plugin for the Bevy game engine
-
bevy_2d_grid
A infinite 2D grid for Bevy
-
bevy_assets_extensions
Extensions for bevy assets, with support of collection as assets and a loader manager
-
bevy_gearbox
State machine system for the bevy game engine
-
bevy-fps-counter
FPS counter plugin for Bevy
-
bevy_play_card
A card crate for the Bevy game engine
-
bevy_card3d_kit
a lib for put and use Card in 3d
-
bevy_hourglass
A flexible hourglass plugin for Bevy applications
-
rekt_lib
Common lib to use the RekT protocol. See the crate homepage to check the protocol RFC.
-
anny-dock
A modern, animated dock for Hyprland built with Rust and Bevy Engine
-
terrain-forge
A modular procedural generation engine for terrain, dungeons, and maps
-
yunfengzh_monolith
Monolith is a framework based on tokio and bevy
-
oximedia-gaming
Game streaming and screen capture optimization for OxiMedia
-
llmwerewolf-rs
LLM Werewolf — a Rust toolkit for building automated social deduction games
-
mappy
A parser for Quake .map files and their descendent formats
-
live2d-cubism-core-sys
Raw FFI bindings to the Live2D Cubism SDK Native Core (v5). Does not bundle the proprietary Cubism Core library — users must obtain it separately from Live2D.
-
rbp
GTO poker toolkit: MCCFR solver, hand evaluation, strategic abstraction, and training pipeline
-
bevy-magic
A Bevy plugin for flexible, data-driven magic systems with enchanting and spellcasting
-
horizon_event_system
Horizon Event System for handling events in the Horizon game server ecosystem
-
blittle
A fast little blitter
-
collider
continuous 2D collision detection for game developement
-
bevy_atmosphere
A procedural sky plugin for bevy
-
enfusion_pak
A library/cli for reading Enfusion game engine
.pakfiles -
pkecs
An ECS framework!
-
viriformat
data-representation used by the viridithas chess engine
-
bevy_rts_camera
An RTS-style camera for Bevy
-
fyrox-ui
Extendable UI library
-
godot-ksni
A Godot GDExtension wrapper for ksni (StatusNotifierItem/AppIndicator)
-
pre-rfc3243-libtw2-gamenet-ddnet
-
symtropy-bevy
Drop-in Bevy plugin for Phi-coupled N-dimensional physics. Builds on the permissive symtropy-bevy-core plugin, adding ConsciousnessField, biometric coupling, and macro-world modifiers…
-
bevy_webgate
A web server integration for the Bevy game engine that allows you to easily append a webserver to Bevy
-
laminar
semi-reliable UDP protocol for multiplayer games
-
pokerproof
Provably fair Texas Hold'em poker engine with cryptographic verification
-
bevy-persistent-windows
A Bevy plugin to easily create and manage windows that remember where they were
-
localgpt-bridge-slack
Slack bridge for LocalGPT
-
rustpower
An experimental ECS world snapshot system built on Bevy, featuring structured archetype storage and manifest-based serialization
-
shadowengine2d
A comprehensive 2D game engine built in Rust with ECS, rendering, audio, assets, animations, and scene management
-
trecs
a tiny and easy to use ecs library
-
agones
SDK for Agones
-
bsru
Beatsaber Rust Utilities: A Beatsaber V3 parsing library
-
bevy_heavy
Mass property computation for Bevy's geometric primitives
-
bevy_procedural_tilemaps
Lightweight 2D tilemap generation with Wave Function Collapse / Model Synthesis for Bevy
-
kittymemory-rs
Rust bindings for KittyMemory - A memory manipulation library for Android and iOS
-
buttons
API for storing and querying input state
-
ftvf
Temporal logic for writing a Fixed Tickrate, Variable Framerate game in Rust
-
gvrtex
interfacing with the GVR texture format used on GameCube/Wii
-
hunpak
PAK files of the game engine Heaps
-
genshin-calc-core
Genshin Impact damage calculation engine
-
bevy_uniform_grid_2d
Bevy plugin for uniform grid spatial indexing
-
bevy_vista
A visual UI editor plugin for Bevy with inspector-driven editing and .vista.ron serialization
-
bevy_tileset
configurable tilesets in Bevy using RON
-
epicinium_lib
Rust bindings for libepicinium, the game logic library of the strategy game Epicinium
-
proof-engine
A mathematical rendering engine for Rust. Every visual is the output of a mathematical function.
-
hecs-schedule
shedulable systems and parallel execution for hecs
-
bevy_symbios_texture
Algorithmic texture generator for Bevy
-
bevy_sky_gradient
Sky rendering plugin for bevy featuring, sky gradient, aurora / northern lights, stars, sun, day-night cycle
-
golem
A (mostly) safe library for graphics programming
-
bevy_mortar_bond
Bevy integration plug-in for mortar language
-
dolly
Composable camera rigs
-
micro_autotile
LDTK autotiling
-
horfimbor-time
Time calculator for the Horfimbor game
-
swarm_pool
Optimized object pooling system for Rust
-
bevy_gpu_test
A test harness for running GPU compute shaders in Bevy and reading back results for CPU-side assertions
-
bevy_bae
Behavior as entities!
-
omt
A set of tiny tools mostly used for game development. A Texture atlas packer, a font converter, a pakfile creator.
-
bevy_top_down_camera
A top down camera written for Bevy
-
bevy_stardust
A networking crate for the Bevy game engine
-
xecs
An Entity-Component-System library
-
gbfs
reading gameboy filesystem archives, a format commonly used in GBA homebrew games
-
bevy_dyn_material
Dynamic Material for Bevy
-
bevy_jakput_manager
input manager for bevy
-
gemath
Type-safe game math with type-level units/spaces, typed angles, and explicit fallible ops (plus optional geometry/collision)
-
uasset
Parsing of Unreal Engine asset files (uassets)
-
squirrel-rng
An impl of
rand::Rngbased on a talk by Squirrel Eiserloh re: Math for Game Programmers -
valinor-domain
Domain models and types for MudWorld text-based virtual world platform
-
bevy_generative
Procedural generation in Bevy
-
simdnoise
SIMD accelerate noise library with runtime feature detection
-
mevy
A growing set of macros, which add witchcraft into bevy!
-
background-runner
Run a heavy task in the background multiple times without blocking the triggering thread
-
rsaber_pc
rsaber
-
amble_engine
Data-first interactive fiction engine and REPL for worlds authored in the Amble DSL
-
bevy_stat_query
Blazing fast and versatile RPG stat system for the bevy engine
-
bevy_slugtext
A high-performance GPU vector text rendering plugin for Bevy
-
nav
handling cardinal directions and transformations
-
bevy_tailwind
TailwindCSS for Bevy
-
rastor
A terminal-based game engine
-
bevy_pixel_art_shader
Pixel art material extension for Bevy — toon shading, CIELAB palette quantization, and Bayer dithering on top of PBR lighting
-
bevy_perf_ui
Customizable Performance/Debug Overlay for Bevy UI
-
rafx-renderer
Rendering framework built on an extensible asset pipeline
-
bevy_gltf_blueprints
Adds the ability to define Blueprints/Prefabs for Bevy inside gltf files and spawn them in Bevy
-
dds-bridge
API for DDS, the double dummy solver for bridge
-
bevy-sculpter
SDF-based voxel sculpting and Surface Nets meshing for Bevy
-
pybevy_storage
PyO3-free storage primitives for PyBevy - validity tracking, borrowed references
-
hoi4save
Ergonomically work with HOI4 saves
-
moirai
Async/await job system for game development
-
snake3
Play the classical snake game on your terminal or use the crate to build your own
-
quicksilver
game framework for 2D games in pure Rust
-
flax
An ergonomic archetypical ECS
-
fantasy-craft
A 2D / 2.5D game engine built on top of Macroquad and Hecs for the Foxvoid Ecosystem
-
univis_ui_style
Theme, fonts, and icons for Univis UI
-
simple_bt
minimal(-ish) behavior tree implementation
-
wow-alchemy
Unified CLI for World of Warcraft file format parsing, conversion, and validation
-
bevy_workbench
A mid-level editor scaffold for Bevy, between bevy-inspector-egui and Unity/Godot
-
bevy_small_menu
A type-safe, headless menu plugin for Bevy Engine, enabling interactive menus from UI Nodes or Sprites
-
suon_task
Async task scheduling integration for the Suon MMORPG framework
-
bevy_fsl_box_frame
A gizmo for manipulating an OBB via 3D picking
-
pixl
The lightweight, powerful Rust game engine and rasterizer built from scratch
-
bevy_procedural_tree
Procedurally generated 3D trees for bevy
-
bevy_family
that helps with creating, updating, and removing parent-child components in Bevy
-
magma_winit
Part of the Magma-API, which is the API of the Magma3D game engine. A winit windowing and input backend implementation.
-
lotus-shared
Shared code for LOTUS scripts and engine
-
bevy_event_chain
Easy trait-like behavior using observers and relations in Bevy
-
narrative-engine
A reusable library for procedural text generation in games
-
bladeink-compiler
Ink compiler for the bladeink runtime — compiles .ink source files into ink JSON stories
-
bevy_mod_billboard
Billboard text and texture support for bevy
-
dos-like
Framework for writing DOS-like applications
-
procmod-core
Cross-platform process memory read/write
-
transform-gizmo-bevy
bevy integration for transform-gizmo
-
bevy_bc_ime_text_field
IME-compatible text field plugin for Bevy (Windows only). Supports both UI and 2D text input.
-
bevy_2dviewangle
Bevy plugin for easier to switch texture base on view angles
-
blue_engine_dynamic
USE blue_engine THIS IS FOR INTERNAL USE
-
reverie-util
reverie-engine
-
bevy-where-was-i
A plugin for Bevy that saves and restores your camera position
-
bevy-steering
Steering behaviors for the Bevy game engine
-
bevy_nested_tooltips
Nested Tooltips for the bevy game engine
-
bevy-debug-text-overlay
A convenient on-screen message print macro for bevy
-
rlifesrc
A Game of Life pattern searcher
-
bevy_cards
no dependency bevy plugin for making card games
-
bancho-packets
osu! bancho packet Reading & Writing library
-
unity-asset-decode
Decode/export helpers for Unity assets (Texture/Audio/Sprite/Mesh) built on unity-asset-binary
-
notation_core
Fun notation - definition for core concepts
-
bevy_mod_reqwest
Bevy http client using reqwest, with a focus on simple usage within the bevy runtime
-
ssq-cli
CLI tool for querying Source game servers using the A2S protocol
-
euca-ecs
Archetype-based ECS with generational entities, type-safe queries, change detection, and parallel iteration
-
bevy_mod_erased_component_registry
Insert components into entities by their
TypeId! -
evenio
An event-driven entity component system
-
rusoto_gamelift
AWS SDK for Rust - Amazon GameLift @ 2015-10-01
-
nevy
Game networking library for the Bevy game engine
-
chidori-debugger
Visual debugger for Chidori
-
piston_window
The official Piston Window for the Piston game engine
-
wow_world_base
Base definitions and functions for World of Warcraft game servers
-
bevy_vox
Load MagicaVoxel Vox file for bevy engine
-
signal-smooth
Frame-rate independent signal smoothing primitives (damped spring, 1-Euro, EMA, deadzone)
-
bevy_lagrange
Bevy camera controller with pan, orbit, zoom-to-fit, queued animations, and trackpad support
-
gdnative
The Godot game engine's gdnative bindings
-
instant-glicko-2
Glicko-2 rating system that allows for instant feedback after games, not just once a rating period closes
-
roast2d_dylib
Support Roast2D dynamic_linking
-
kengaai-model-loader
3D model loader for KengaAI Engine (glTF support)
-
csa
A Shogi game serialization/deserialization library in CSA format
-
ruscii
Terminal graphics engine
-
rust-rpg-toolkit
An engine for creating action RPGs with Rust and/or JSON
-
bevy_novel
Visual Novels with Bevy
-
bevy_pretty_nice_menus
A menu stack abstraction for Bevy
-
bevy_system_reflection
reflecting systems, schedules, system sets and rendering schedules
-
bevy_pixel_buffer
draw pixels in bevy
-
jugar-yaml
ELI5 YAML-First declarative game creation for children ages 5-12
-
break-eternity
A numerical library to represent numbers as large as 10^^1e308 and as 'small' as 10^-(10^^1e308)
-
termray
Generic TUI raycasting engine — grid maps, DDA walls, floors/ceilings, sprites
-
oxidized-nbt
Complete Minecraft NBT codec — binary reader/writer, SNBT parser, serde integration, gzip/zlib I/O, memory accounting
-
imperator-tiger
Validator that checks Imperator: Rome user mod files for mistakes and warns about them. For example: missing localizations, or using a country trigger on a character. Imperator: Rome…
-
oxide-engine-api
API for Oxide game engine plugins
-
bevy_clay_tiles
A procedural-mesh building system for bevy
-
revier-glam
Modification of the library glam-rs for the game engine Revier
-
bevy_kana
Ergonomic, opinionated utilities for Bevy — type-safe math, input wiring, and more
-
grain
A lightweight Entity Component System (ECS) library
-
kiwi-ecs
A performant, small and versatile entity component system
-
interpulse
interacting with pulseflow apis
-
bevy_jamkit
Jamkit is a small set of simple, plug-and-play Utilities to facilitate a game jam submission
-
bevy_skybox
A skybox from an image for bevyengine.org
-
bevy_mod_props
Bevy utilities for high-specificity programming
-
operant
High-performance SIMD-optimized reinforcement learning environments
-
cecs
Entity database for the game 'Cao-Lo'
-
beet_net
Very bevy networking utilities
-
bevy_key_rotation
Access and refresh token rotation for Bevy applications
-
sunray
hardware ray-tracing library
-
hexlab
A hexagonal maze generation and manipulation library
-
bevy_full_throttle
Enable CPU performance mode for Bevy games
-
ambient_element
Element is a React-inspired virtual tree library for the Ambient runtime
-
bevy-hikari
Realtime Path Tracer for the Bevy Engine
-
bevy_mod_speedup
collection of ways to increase the performance of your application
-
om-fork-distance-field
Temporary fork! Generate distance fields from images for pseudo-vector rendering
-
tomt_bevycss
Expansion and fixes based on bevy_ecss. Allows for using a slightly wider subset of CSS to interact with Bevy ECS. Now on Bevy 0.13!
-
bevy_spacetimedb
Use SpacetimeDB in your Bevy application
-
collision2d
2d collision detection library
-
godot-testability-runtime
Embedded Godot runtime for comprehensive Rust testing
-
bevy_wind_waker_shader
A toon shader that looks like the one used for characters in The Legend of Zelda: The Wind Waker
-
bevy_time_runner
General timing system for the Bevy game engine
-
xuko
Rust utility library
-
bitboard_chess_engine
A chess engine with UCI support
-
bevy_mod_ffi
FFI utilities for Bevy
-
mevy_ui_syntax
token handling for mevy_ui!
-
mapgen
Map generator for games (dungeons, worlds etc.)
-
be_tween
Helper library to support tweening - with inital support for bevy
-
swoop-ui
A swifuUI style bevy engine ui toolkit
-
vidi-charts
High-performance data visualization library for Rust, powered by Bevy
-
d3d11
Safe(r) bindings to the D3D11 API
-
cortenforge
Umbrella crate for the CortenForge stack; re-exports app-agnostic crates with feature wiring
-
rpg-stat
computer stats for RPG game development
-
thallium
A basic game engine
-
bones_lib
The Bones game development library
-
tato
A ridiculously obsolete collection of zero-dependency game development modules that can run on any computer, even potato-powered ones!
-
ascending_time
Some Time Helpers for the ascending group
-
limnus-message
message container
-
kengaai-scene-fps
structures and functions for loading KengaAI Engine FPS scenes
-
rl-traits
Core traits for reinforcement learning environments, policies, and agents
-
bevy_map_dialogue
Dialogue tree types and runtime for bevy_map_editor
-
bevy_request
A HTTP client library for bevy
-
wobj
Wavefront OBJ polygonal geometry and MTL material parser library
-
inkling
Limited implementation of the Ink markup language
-
treasury-import
FFI for treasury importers
-
weirdboi_bevy_colour
Colour palettes for Bevy, with macros for compile-time palette definitions
-
bevy_zeroverse_ffi
bevy zeroverse ffi library
-
pybevy_bytecodevm
Bytecode VM for PyBevy expressions
-
micro-games-kit
Micro Games Kit
-
cobject
A game engine that uses minifb as a foundation and currently only supports 2D
-
bevy_perf_hud
Configurable performance HUD overlay plugin for Bevy apps
-
game_stat
handling stats that can change with modifiers, most commonly seen in games
-
rx_core_subject_publish
publish subject for rx_core
-
gravita-engine-core
Core engine orchestration layer for Gravita game framework
-
realism
A high-performance, production-ready scene management crate for Rust game engines
-
bevy_shader_graph
Shader graph for Bevy
-
bevy_jpeg2k
JPEG 2000 image loader for Bevy
-
rmmesh
A fast 3D mesh import/export crate with a compact binary format, ready for Vulkan/OpenGL/DX11/DX12
-
rydit-science
Science module for RyDit - Bezier curves, Statistics, Geometry, Optical illusions
-
nitro_net
Various network APIs for Nitrolaunch
-
signal-fish-server
A lightweight, in-memory WebSocket signaling server for peer-to-peer game networking
-
dreamwell-analytics
DQL (Dream Query Language) engine — cold-path analytics, proof verification, and federated query for Dreamwell
-
duck_back
Options and results are water off a duck's back
-
tma_engine
A lightweight crate for defining, composing, and applying 2D affine transformations
-
bevy_movie_player
movie player plugin for bevy
-
rusty_sword_arena
Library/repository for the half-day Rust tutorial teaching you how to make a game client in Rust
-
olc_pixel_game_engine
Rust bindings for olcPixelGameEngine
-
qmi
A variant of ECS where topology matters and makes us happy
-
ym2149-ym-replayer-cli
Command-line player for YM chiptune files
-
wavefront_loader
A loader/exporter into wavefront for debugging and visualizing geometry algorithms
-
allegro_examples
Allegro 5 wrapper examples
-
bevy_http_client
HTTP client for Bevy
-
rsaber_lib
rsaber
-
bevy_replicon_snap
High-level networking crate that extends the bevy_replicon crate to allow snapshot interpolation and client-side prediction
-
bevy_ufbx
FBX asset loader for Bevy using the ufbx library
-
rsffish
wrapper for fairystockfish based on https://github.com/mind-sports-games/Fairy-Stockfish-Lib
-
scion
Game making library on top of wgpu, winit, hecs
-
game_mem_utils
reading and writing process memory on Linux, designed for easy trainer creation!
-
vrc-get-vpm
Open Source client of VRChat Package Manager. This is the library is made for vrc-get.
-
gyges
board game Gygès
-
rust_flightplan
Loads a flight plan from SimBrief and decodes it
-
bevy_despawn_particles
An event-based plugin for Bevy to spawn particles on despawn that are built from the original texture
-
bevy_exclusive_with
A Bevy plugin to define exclusive sets of components for ergonomic querying
-
hpyhex-rs
Simplified implementations of the HappyHex game components and hexagonal system in Rust
-
obel
A refreshingly simple data-driven game engine and app framework
-
a2s
Source A2S query
-
bevy_midi
Send and receive MIDI data to and from bevy and other programs or controllers
-
gorrosion
Go/weiqi/igo/baduk/goe whatchamacallit
-
gravita-physics
A modular 2D physics engine for real-time games and simulations
-
aalo
aka bevy-inspector-haalka, a bevy_ui-native inspector for Bevy
-
geo-bevy
Generate Bevy meshes from
geotypes -
bevy-ichun
kinematic character controller for avian3d
-
crossbow
Cross-Platform build tools and toolkit for games
-
egui_net_ffi
Rust-C# interop for Egui.NET
-
bevy_alchemy
An experimental, status effects-as-entities system for Bevy
-
bluecs
Archetype-based Entity-Component-System
-
bevy_gantz_egui
Egui integration for bevy_gantz
-
sdl2
SDL2 bindings for Rust
-
libgnome-games-support
Rust bindings for libgnome-games-support
-
modde-ui
GUI application for modde
-
gn-communicator
Component for communication for game-night microservices
-
bevy_prototype_debug_lines
A prototype plugin providing a simple line drawing API for bevy
-
zzstat
A deterministic, hardcode-free stat calculation engine designed for MMORPGs
-
bevy_entitiles
A 2d tilemap library for bevy. With many useful algorithms/tools built in.
-
zero_ecs_build
Build scripts for: ZeroECS: an Entity Component System (ECS), using only zero-cost abstractions
-
bevy_alight_motion
Bevy plugin for loading and playing Alight Motion project files
-
tiny-game-framework
Tiny game framework for creating games!
-
bevy_particle_systems
A particle system plugin for Bevy
-
bevy-parallax
A Bevy plugin for creating a parallax effect
-
bevy_asky
question-and-answer UI middleware for Bevy
-
stourney
Splendor tournament manager - an app for running Splendor tournaments between autonomous agents
-
veloren-serverbrowser-api
the format of the veloren serverbrowser, so it can be used by other tools
-
dice_expression
help you parse and execute some dice expressions
-
bevy_vrm
Bevy plugin for loading VRM avatars
-
remodel
read, modify, and write Roblox objects
-
bevy-convars
convars (config or console variables) for configuring your Bevy application
-
good-web-game
An alternative implementation of the ggez game engine, based on miniquad
-
chilloutvr
Unofficial rust types of ChilloutVR's API
-
bevy_map_editor
Full-featured map editor for Bevy games with autotile support
-
bevy_query_observer
More sophisticated observers for Bevy
-
bevy_entity_uuid
Keep track of entities via uuid
-
orthrus-ncompress
Orthrus module supporting Nintendo compression formats
-
schminput
An Action Based Input Manager for Bevy
-
bevy_woff
Bevy plugin for loading .woff and .woff2 web fonts as assets
-
ltk_overlay
WAD overlay/profile builder for League of Legends mods
-
fyrox-resource
Asset management crate for the Fyrox engine
-
bevy_basisu_saver
A bevy asset processor to transform images to basisu ktx2 textures
-
bevy_mod_observable_timer
An observer-based timer for bevy
-
inv-sys
effective inventory system for games
-
bevy_asset
asset functionality for Bevy Engine
-
oxide_ecs
Oxide Core ECS runtime
-
bevy_synthizer
A Bevy plugin for Synthizer, a library for 3D audio and synthesis with a focus on games and VR applications
-
steam-vent-proto
Protobuf structs used by the Steam client protocol
-
u64-id
A tiny library providing a u64 backed id
-
bevy_aspect_ratio_mask
A Bevy plugin for fixed aspect ratios, letterboxing, and UI scaling in 2D games
-
emotiva
Lightweight layered 2D character animation runtime written in Rust
-
bevy_sync
Plugin for synchronizing entities and components between server and its clients
-
bevytui
Terminal-style UI primitives and font-backed renderer plugin for Bevy
-
waymark
Pathfinding and spatial queries on navigation meshes
-
roead
Rust port of oead C++ library for common Nintendo formats
-
beet
Malleable Application Framework
-
bevy_simple_compute
App compute plugin for Bevy
-
dogsoap
Data-Oriented, Simple, Goal-Oriented Action Planning
-
astrelis
A modular 2D/3D game engine framework
-
anymotion
Prototype skeletal animation library for ECS-native game engines
-
vulk-gen
Vulkan bindings for Rust, except only the bleeding edge features
-
bevy_axon_cli
CLI tool for bevy_axon metadata extraction
-
game-cheetah
High-performance memory scanner/editor and game trainer for Linux, Windows, and macOS
-
hexga_graphics
The default graphic renderer of hexga_engine
-
bevy_track_asset
Propagate asset changes to dependent components and resources in Bevy
-
saft
Signed distance field function compiler/interpreter/discretizer/mesher
-
ta-connector-unreal
Unreal Engine 5 connector for Trusted Autonomy
-
bevy_2d_line
A line rendering plugin for Bevy
-
bevy_layered_materials
A StandardMaterial-compatible Material that accepts multiple textures in 2d texture array form
-
brett-core
The core library of the brett-engine
-
amble_data
Shared data model used by amble_engine and amble_script for the Amble game engine
-
extol_sprite_layer
Explicitly-defined sprite layers for Bevy, including automatic y-sorting
-
dogoap
-
bevy_panorbit_wasd_camera
A basic pan and orbit camera in Bevy with WASD support
-
renzora
game engine
-
gravitron_ecs
performant ECS for Gravitron
-
tapaculo
Lightweight Rust server for real-time and turn-based multiplayer communication
-
card-game
Framework for building card games
-
bevy_audio_controller
Bevy plugin for managed audio playback
-
bevy_utilitarian
A collection of mostly maths, interpolation and geometric utilities that aim to make Bevy programmers happier
-
sceller
An ECS crate written in Rust based on the tutorial series by Brooks Builds on Youtube
-
bevy_tasker
Cross-platform async task spawning for Bevy — web workers via microtask queue on WASM, thread pool on desktop
-
rship-entities
rship entities
-
goita
Core game engine for Goita, including round/game state management, turn validation, scoring rules, ans special hand event handling
-
haalka_futures_signals_ext
vendored version of MoonZoon's futures_signals_ext, as it is yet to be released as a crate
-
cube-core
Cube core for 'kostka' simulation
-
tnaps
entity-component-system framework in Rust
-
praeda
A procedural loot generator library with C++ and C# FFI bindings
-
bevy_scroller
Scroller plugin for Bevy
-
ici-files
Encode/decode ici files
-
bevy_fast_tilemap
A GPU accelerated tilemap for bevy
-
go_game_board
Go/Baduk/Weiqi rules implementation with libEGo-based algorithms
-
ruci
A UCI (Universal Chess Interface) crate
-
bevy-test-harness
test harness for Bevy applications
-
gw2lib-model
Models for gw2lib
-
macroquad-canvas-2d
Add canvas functionality to macroquad
-
bombahead-rs
Rust SDK for building Bomberman bots that connect to a Bombahead game server over WebSockets
-
aquila_cli
Aquila server CLI
-
dnd_lib
Dungeons & Dragons character building and management library
-
shogi_core
Fundamental types and functions for shogi
-
wow_dbc
parsing World of Warcraft DBC files for 1.12, 2.4.3 and 3.3.5
-
bevy_variable_property
A generic way to define properties as static, random, or randomized on an interval
-
bevy_noised
2D seeded noise primitives for Bevy with matching CPU and WGSL implementations
-
oab
Open Auto Battler - a deterministic auto-battler game engine
-
azalea-client
A headless Minecraft client
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
gravita-math
Minimal 2D math primitives for game development and physics simulation
-
xwt
A common WebTransport interface for browser and native. Write once, run anywhere. Originally intended for use with bevy.
-
anvilkit-core
Core types, math library, and time system for AnvilKit game engine
-
sanqi-core
Core rules and data structures for the Sanqi board game
-
inexor-rgf-core-plugins
Inexor - Reactive Graph Flow - Core - Plugins
-
firefly-keyboard
Virtual keyboard for Firefly Zero apps
-
moecs
Micro ECS engine. A small and lightweight ECS engine for Rust projects.
-
ldtk2
A thin crate for people who just want to use ldtk files freely
-
cloudiful-bevy-input
Reusable Bevy input abstraction for game-defined actions
-
bevy_spatial
tracking bevy entities in spatial indices
-
issun-bevy
ISSUN plugins for Bevy ECS
-
bevy_ogle
A camera library for 2d vector games
-
bevy_inochi2d
Renderizador independiente de Inochi2D impulsado por el backend wgpu de Bevy
-
bevy_magic_light_2d
Experimental dynamic 2D global illumination system for Bevy, based on SDF ray-marching and screen space irradiance cache probes
-
xinput-mapper
Functional helpers to convert DInput YAML mapping into an XInput-like state
-
bracket-lib
Meta-crate holding the entirety of bracket-lib (and exposing it). Use this for the full roguelike toolkit experience.
-
bevy_transform_gizmo
A 3D transform gizmo for Bevy
-
discord_game_sdk
Safe wrapper for the Discord Game SDK
-
fume
A strongly-opinionated Rust wrapper for steam web APIs
-
bitsy-parser
A parser and utilities for working with Bitsy game data
-
kurinji
Input map for bevy
-
bevy_coroutine
run coroutines in Bevy
-
minacalc-sys
Raw Rust bindings for MinaCalc C++ library (Etterna rating calculator v515)
-
shogi
Bitboard based Shogi library. Board representation, move handlings and various time control utilities.
-
migui
Immediate Mode GUI in pure Rust for game engines
-
localgpt-bridge-whatsapp
WhatsApp bridge for LocalGPT
-
playband
game engine
-
sdec-repgraph
Replication graph and interest management for sdec
-
weasel
A customizable battle system for turn-based games
-
quake-map
Parser for Quake and Quake II .map files
-
lightyear_transport
Packet handling for the lightyear networking library
-
unity-pack
Create Unity .unitypackage files and assets from Rust
-
seawater
A high performance entity component system useful as a backend for developing GUI applications and video games
-
goud_engine
GoudEngine core — internal implementation crate. Use goud-engine-sdk for the public API.
-
omelet
A lightweight, game-orented math library for Rust, including vectors, matrices, and quaternions
-
bevy_malek_async
async runtime agnostic access to the bevy ecs
-
procedural_tilemaps_core
Lightweight 2D tilemap generation with Wave Function Collapse / Model Synthesis for Bevy
-
nightshade-editor
An interactive editor for the Nightshade game engine
-
bevy_spliff
doing joins in bevy
-
warbler_grass
A bevy plugin for creating 3d grass in your game
-
ra2-types
Shared types definitions for Red Alert 2
-
bevy_pipelines_ready
Bevy plugin for tracking render pipeline status
-
dump-roblox-api
Dumps all roblox classes and enums into either a luau table or Rust structs and values
-
bevy_tiled_loader
Asset loader for the Tiled data parsed
-
bevy_emoji
Color emoji rendering for Bevy — bypasses swash's broken CBDT support by extracting bitmap glyphs directly via ttf-parser
-
renetcode
Server/Client network protocol library for multiplayer games
-
bevy_channel_trigger
Send events via a channels form anywhere (eg. c-ffi) to Bevy Observers
-
bird_barrier
A Bevy plugin for coordinating setup/loading tasks with dependency management
-
seldom_pixel
Bevy plugin for limited color palette pixel art games
-
bevy_lazy_signals
An ad hoc, informally-specified, bug-ridden, kinda fast implementation of 1/3 of MIT-Scheme
-
bevy_rectray
A minimal 2d layout system for bevy
-
arcane-core
Core library for Arcane - agent-native 2D game engine (TypeScript runtime, renderer, platform layer)
-
bevy-tnua-physics-integration-layer
Components for integrating physics backends with bevy-tnua
-
uika-ue-flags
Unreal Engine reflection flag constants for uika
-
bevy_sprinkles
GPU particle system for Bevy
-
piston3d-cam
3D camera and navigation
-
tge
A lightweight cross-platform 2D game framework written in pure Rust and based on OpenGL 3.3+
-
bevy-hid
A hid plugin for bevy
-
bevy_mod_lockdown
reduce the attack surface your application offers
-
eulumdat-bevy
3D scene viewer for photometric data using Bevy game engine
-
limnus-system
Limnus systems
-
axon_rt
Core library for axon
-
sina
A modern 2D graphics rendering engine written in pure Rust, inspired by Skia
-
keket-http
HTTP asset fetch engine for Keket toolkit
-
ecsilarant
Sketch of an ECS for the future
-
minifb-ui
Light wrapper around minifb to make creation of windows and UI elements simple
-
gxter-cli
A command-line utility creating and reading GTA 3/VC/SA GXT (text string) files
-
celesterender
Renders celeste maps
-
zara
Zara survival engine
-
bevy_mod_ffi_guest_sys
Low-level FFI bindings for bevy_mod_ffi guests
-
bevy_prng
providing newtyped RNGs for integration into Bevy
-
martini_rtin
RTIN algorithm
-
bevy_gltf_trait
Customizable Bevy Engine GLTF loading
-
bevy-ui-dsl
A DSL library that simplifies the creation of widgets for bevy_ui
-
zcomponents
stupid component storage
-
ABC-ECS
fast, and flexible Entity-Component-System library for Rust
-
bevy_deepzoom
Deep Zoom Image (DZI) tile streaming Bevy
-
bevy_replicon_quinnet
Integration with bevy_quinnet for bevy_replicon
-
rusterix
game engine of Eldiron
-
macroquad-particles
Visual effects editor based on macroquad and megaui
-
bevy_ui_styled_widgets
Styling for bevy headless widgets
-
avila-mesh
3D mesh structures with PBR materials, primitives (cube, sphere, plane) - 100% Rust
-
casino_poker
that provides hand ranking & the backend for poker games
-
bevy_bundletree
Spawn trees of bundles in the Bevy game engine
-
moonshine-object
Bevy Entities are nice. Objects are better!
-
bevy_round_ui
rounded-rect material shader for bevy_ui
-
procmod-layout
Struct mapping with pointer chain traversal via derive macros
-
bevy_platform_dirs
Expose the platform-dirs crate as a Bevy Resource
-
tri_grid_sim
Deterministic tick-based simulation on a 2D grid with directional triangles
-
bevy_terminal_display
A plugin for the Bevy game engine which enables rendering to a terminal using unicode braille characters
-
jackdaw_animation
Animation authoring and playback for the Jackdaw editor — thin UI over Bevy's AnimationClip / AnimationGraph / AnimationPlayer
-
urd-quest
Interactive terminal runner for Urd dialogue scripts
-
pobsd-parser
Simplistic parser for the PlayOnBSD Database
-
chicory
A UCI-compatible, dependence free, chess engine
-
switchbrew_bevy
help port Bevy games to Nintendo Switch using emulators
-
bevy_iced
Iced integration for Bevy
-
bevy-gym
Bevy ECS plugin for parallelised RL environment simulation
-
bevy_voronoi
A low-level Bevy library to generate Voronoi diagrams from 2d meshes
-
bevy-scene-hook
Ad-hoc component insertion for bevy scenes
-
regecs
Rust Extended Generic ECS (REGECS)
-
bevy_startup_tree
A bevy extension for inserting startup system dependency graphs into the app
-
pulz-schedule
For scheduling systems and managing their resources
-
bevy-ui-navigation
A bevy plugin to make implementing ui navigation in your game a piece of cake
-
bevy_auto_plugin_shared
shared lib for bevy_auto_plugin
-
bevy_flowkit
A UI workflow library for Bevy Engine
-
geng
Game ENGine
-
gloss-hecs
A wrapper over hecs for easy use with gloss
-
stellare-types
Common types for the Stellare ecosystem
-
simple-game-utils
games
-
pixel_loop
A pixel based drawing engine based on the idea of a self stabilizing update loop
-
bevy_query_macros
Bevy query macros
-
bevy_metrics_dashboard
Metrics dashboard for Bevy apps
-
ca-formats
Parsing pattern files for Conway's Game of Life
-
hecs-component-provider
Easily define behavior for sets of components when using the hecs ECS library
-
bevy_talks
A Bevy plugin to write dialogues for your characters to say and do things, together with player choices
-
moonshine-view
Generic Model/View framework designed for Bevy
-
marathonctl
Command-line control interface for Marathon multiplayer game engine
-
spine2d
Pure Rust runtime for Spine 4.3 (unofficial)
-
myth_render
Core rendering system for the Myth engine (render graph, pipeline, GPU management)
-
thomas
An ECS game engine
-
bevy_easy_database
A persistent storage solution for the Bevy game engine that automatically serializes and persists your components to disk using fjall as the underlying database
-
teng
A basic game engine for the terminal
-
pulz-ecs
An archetype based ECS
-
bevy_ort
bevy ort (onnxruntime) plugin
-
min_timer
f64 based duration and timer; moreover, a main loop implementation using it
-
starlib
A 2D grid-based TUI game engine
-
fts_units
that enables compile-time type-safe mathematical operations using units of measurement
-
dynec
An opinionated ECS-like framework
-
waking-git-core
implementing the core functionality of waking-git
-
maze_rs
maze game in rust
-
lyceris
An open source Minecraft launcher library
-
hnefatafl
building software for the tafl family of board games
-
wobl
multibackend textbased game engine
-
bevy-canvas-2d
A fast chunked 2D pixel canvas for Bevy with dirty-rect GPU uploads
-
mod_plugins
Reduce plugin boilerplate in the Bevy game engine
-
aeronet_steam
Steam networking IO layer implementation for
aeronet -
ldtk_map
reading ldtk maps for usage in games
-
symtropy-render-bridge
Project N-dimensional physics worlds into Bevy 3D rendering, with first-class 4D cross-section slicing (Miegakure-style). Bridge crate between symtropy-physics and Bevy.
-
rydit-core
Core trait and registry for RyDit modules - Android game engine
-
pyxel-platform
Platform abstraction layer for Pyxel, a retro game engine for Python
-
bevy_octopus
ECS based networking library for Bevy
-
bevy-orbit-camera
A tiny Bevy plugin for an orbit camera controller
-
bevy-dynamic-viewport
dynamic viewport system for bevy engine
-
dokedex
cli for Dokedex, a godot game content authoring tool
-
interfrost
interacting with Polyfrost/pulseflow apis
-
magma_app
Part of the Magma-API, which is the API of the Magma3D game engine
-
ico_math
An opinionated SIMD Math Library for games and graphics in Rust
-
bevy_spritesheet
bevy extensions with support for selecting a sprite index depending on an associated state
-
rubot
A generic game bot written in Rust
-
luminol
FOSS recreation of RPG Maker XP in Rust with love ❤️
-
bevy_link_window_to_monitor
A small micro-crate to associate Windows and Monitors
-
shard-ecs
The Shard Entity Component System
-
bevy-web-resizer
Automatically resize your Bevy app on the web (wasm) to the size of the browser window
-
oxihuman
Privacy-first, client-side human body generator — pure Rust MakeHuman port (facade crate)
-
nrd-sys
Rust FFI for NVIDIA Realtime Denoiser
-
crafter-core
Core game logic for Crafter - a Minecraft-like 2D survival game engine
-
aerox
高性能游戏服务器后端框架
-
specs-hierarchy
Scene graph type hierarchy abstraction for use with specs
-
ticktime
struct to convert a tick to an in game date time
-
wormhole-packager
CLI tool for building and packaging Wormhole games
-
ombre
Shadowy game and graphics library for Rust
-
rrise
binding for Wwise
-
raster-fonts
Bitmap font creation tool and accompanying metadata deserialization library
-
kazam-replay
Replay loading, indexing, and playback controls for Pokemon Showdown logs
-
directb2s
reading visual pinball directb2s files
-
bevy_repl
Add a REPL to headless Bevy applications
-
fennel-engine
Main package of Fennel game engine providing higher level API
-
widgetui
A bevy like widget system for ratatui and crossterm
-
sanqi-engine
Search and evaluation engine for the Sanqi board game
-
bevy_vulkano
Vulkano Backend for Bevy
-
bevy_nostr
Bevy plugin for the Nostr protocol
-
pixelsrc
GenAI-native pixel art format and compiler
-
tx2-cli
Command-line interface for TX-2 ECS - inspect, debug, and manage TX-2 applications
-
krunker-maze-generator
Generates mazes for Krunker maps
-
ggsdk
that exports several types related to game development
-
pybevy_control
HTTP control API for PyBevy - enables remote interaction with running scenes
-
bevy_mod_inverse_kinematics
An inverse kinematics plugin for the Bevy engine
-
bevy_console_parser
console command parser for bevy_console
-
moltrun
High-performance game engine library with AI capabilities, built on wgpu for modern 3D graphics and physics simulation
-
cortenforge-vision-runtime
Bevy plugins for capture and inference runtime built on vision_core for the CortenForge stack
-
ggbasm
Generating Gameboy Assembler
-
bevy_keith
2D graphics library for the Bevy game engine
-
lune-std-roblox
Lune standard library - Roblox
-
bevy_ineffable
A simple-to-use input manager for bevy that empowers players and makes accessibility easy
-
bevy_c3d
A plugin for loading C3D motion capture files into Bevy
-
dynasty-rs
A powerful class inheritance system for Rust game engines
-
tm-sys
FFI bindings for the machinery api
-
mireforge-render
standard render types for 2D
-
sweet
A delightful cross-platform test runner
-
tauri-plugin-gamepad
A plugin for Tauri that provides a polyfill for Gamepad Web API that works on most common platforms
-
bevy_mod_bbcode
Use BBCode-formatted text inside of Bevy
-
bevy_replicon_attributes
Extends bevy_replicon with attribute-based visibility control
-
bevy_reconstruction
bevy UI wrapper for burn_reconstruction multi-view reconstruction
-
iyes_loopless
Composable alternatives to Bevy's States/FixedTimestep/RunCriteria
-
rusting_engine
A high-performance Vulkano-based 3D engine with GPU physics
-
component_group
Defines the ComponentGroup trait for managing a group of specs::Component instances and moving them between specs::Worlds
-
bevy_mod_osc
OSC plugin for Bevy engine
-
bracket-pathfinding
Pathfinding and field-of view utilities. A Star, Dijkstra. Part of the bracket-lib family.
-
palkia
Entity Component Message architecture a la Caves of Qud
-
gdext-gen
Autogenerates a .gdextension file for using Rust to make a Godot GDExtension. It provides all the libraries pathfinding and a way to automatically link the default icons to the new…
-
bitsy-file
A parser for Bitsy game files
-
coup
game implemented in the CLI
-
aspeng
game engine built around the ECS architecture
-
bevy_blob_loader
Bevy plugin for loading assets from JavaScript blob URLs
-
eternalfest_core
Core crate for Eternalfest
-
bevy-cache
A caching layer for Bevy assets with manifest persistence, expiry, and per-entry max age support
-
soorat
— GPU rendering engine for AGNOS
-
igdb
Video Game Database Api
-
rollo
A Rust-based multiplayer framework
-
bevy_simple_water
Bevy plugin for easily creating and applying water shader materials to 3D meshes
-
bevy_text_mode
Bevy plugin adding a texture atlas sprite with configurable background and foreground colors
-
revy
Proof-of-concept time-travel debugger for Bevy, built with Rerun
-
astrelis-winit
Astrelis integration for winit
-
rcon-cli
A RCON client library and CLI for game server administration
-
benimator
A sprite animation library for rust game development
-
ccdb
A small terminal based game engine
-
gmod
A swiss army knife for creating binary modules for Garry's Mod in Rust
-
q_service
Services for Bevy
-
rbp-gameplay
Poker game engine with state management, action handling, and settlement
-
bevy_pxtxt
Create fonts and render text in bevy based on a bitmap source image
-
edict-proc-lib
Powerful entity-component-system library
-
big-brain
AI library
-
kj-bevy-realistic-sun
Sets a directional light to point in a realistic direction, accounting for latitude and time of year
-
aetheris-transport-webtransport
Browser-native WebTransport layer for the Aetheris Engine (QUIC/HTTP3)
-
riichi
Japanese Riichi Mahjong game engine
-
bevy_eventlistener
Event listeners and callbacks for bevy
-
ico_memory
Experimental custom memory manager and handle-based resource manager
-
mun_target
Describes compilation targets for Mun
-
mortar_cli
Mortar language command line tool
-
bevy-nest
🪹 A telnet plugin for getting MUDdy in Bevy
-
galeon-engine-three-sync
WASM-friendly bridge from Galeon ECS to Three.js render extraction
-
flecs_ecs_sys
sys binding for C/CPP flecs ECS library https://github.com/SanderMertens/flecs
-
bevy_hotpatching_experiments
Hotpatch your Bevy systems, allowing you to change their code while the app is running and directly seeing the results!
-
bevy_heightmap
Create meshes from heightmap PNGs in the Bevy game engine
-
forged-in-lost-lands
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
bevy_unified_input
A unified input primitives
-
asciivation_duty_renderer
in-terminal 3d renderer for a game i was/am writing, but that may also be useful as a standalone library
-
ogmo3
reading and writing Ogmo Editor 3 projects and levels
-
bevy_blur_regions
A Bevy plugin to selectively blur regions of the screen
-
bevy_ghx_grid
Bevy plugins for 2D & 3D grids
-
goggles
Building blocks for a hibitset based ECS library
-
bevy_serialization_extras
managing serialization with moonshine_save + wrappers
-
modern-minesweeper
minesweeper game built with Rust + Slint
-
bevy_guessture
Bevy plugin wrapping the
guessturecrate’s gesture recognition API -
matrix_engine
a small game engine developed by drmatrix
-
bevy_ads_common
Basic crate for Bevy game engine ads integration
-
obel_platform
Platform agnostic support
-
inochi2d-parser
Analizador tipificado y representación intermedia para archivos INP/INX de Inochi2D
-
pincushion
Uniform mesh sampler with Unity3D/C# bindings
-
gravita-assets
Asset loading and management utilities for Gravita game framework
-
gba_rumble
Rumble functionality on the Game Boy Advance
-
macroquad-canvas
Adds canvas functionality to Macroquad
-
aetheris-ecs-custom
High-performance custom ECS with SoA layout and manual dirty tracking
-
bevy_quadtree
A quadtree plugin for bevy
-
retrofire
90s style software 3D renderer and graphics tools
-
solstack
Enables management of your app's or game's control flow through a simple state stack machine
-
chunked
An Entity Component System that works by organising like entities into chunks
-
rantz_suite
A combined suite of tools provided by Rantz for use with the Bevy game engine
-
xtk-ecs
xtk entity component system
-
bevy_two_entities
A few convenience traits for working with Bevy Queries
-
fyrox-project-manager
Project manager for Fyrox engine
-
cloudiful-bevy-camera
Reusable camera switching core for Bevy
-
matchforge
A plug-and-play matchmaking SDK for multiplayer games
-
fixedstep
macro to create a fixed timestep loop for a game
-
bevy_mod_wanderlust
A character controller library for Bevy Engine
-
bevy_webgl2
A webgl2 wasm32 render backend for Bevy Engine
-
thunderstore-api
API bindings for the Thunderstore Web API
-
ccdb_script
A small language to add in games for easy modding
-
http2byond
that handles /world/Topic() communication with BYOND servers
-
service-locator
Thread-safe generic service locator
-
re_chunk
A chunk of Rerun data, encoded using Arrow. Used for logging, transport, storage and compute.
-
bevy-alt-ui-navigation-lite
A bevy plugin to make implementing ui navigation in your game a piece of cake
-
spire_tween
A Slimy tweener library for Godot(4.4+), inspired on the design of DoTween(3rd party package for Unity)
-
bevy_meshem
that offers a flexible and efficient way to generate meshes from a grid of Voxels
-
bevy_web_popups
Allows to trigger web/dom based popups/alerts and textinput in bevy
-
bevy_wasm
Run WASM systems in Bevy
-
bevy_roll_safe
Rollback safe utilities and abstractions for Bevy
-
posturn
Build turn-based games with
asyncRust -
gravita-input
Input handling abstraction layer for Gravita game framework
-
bevy_simpletoon
A super simple post processing toon shader
-
stdb-common
Core utilities and common functionality for SpacetimeDB-based game development
-
bevy_symbios_shape
Bevy integration for Symbios Shape
-
basisu_c_sys
Raw Rust binding for the Basis Universal pure C API
-
world-map-gen
Command line tool and library to generate random game world maps for both Rust and WebAssembly
-
bevy_wry
A tauri-apps/wry integration with Bevy engine
-
simple-game-engine
A minimal game engine inspired by the OLC Pixel Game Engine
-
sunflowerecs
A hybrid ECS library written in Rust
-
bevy_mesh_obj
Parse Wavefront .obj files into Bevy Meshes
-
bevy_magic_fx
Define mesh-based vfx in serialized files
-
ifengine
Interactive fiction library
-
erupt-bootstrap
vk-bootstrap for Rust
-
kaige_ecs
Fork of the Legion ECS library, with some changes to make it more suitable for use in Kaige
-
bevy-async-commands
Asychronous Commands context for Bevy Game Engine
-
curseofrust-msg
Curseofwar messaging protocol implementation
-
nightshade
A cross-platform data-oriented game engine
-
ron_asset_manager
A dead simple crate to manage Ron based assets which depend on other assets
-
bevy_la_mesa
Build card games with Bevy
-
bevy_background_compute
Bevy plugin for better task handling
-
gerg_ui
A little wrapper I've written for creating UI screens from files for the BevyEngine
-
glam-ext
Transform, isometry and more extension types for glam-rs
-
rglua
Toolkit for garrysmod development with the source sdk and luajit api
-
bevy-trait-query-0-14-0
trait queries for the bevy game engine
-
twee-tools
A compiler for Twine stories
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
bevy_trenchbroom_avian
Integration between
bevy_trenchbroomand the Avian physics engine -
gaviota-sys
Low level bindings for libgtb, a library for Gaviota tablebase probing
-
ue-types
Common Unreal Engine data types for Rust game servers
-
wipe-rs
Rust bindings for the WIPE 3d engine
-
zvxryb-broadphase
A broadphase collision detection library
-
impacted
2d collision test for arbitrary convex shapes
-
mrdirector
A narrative game development package for the Turbo Game Engine
-
ck3-tiger
Validator that checks Crusader Kings 3 user mod files for mistakes and warns about them. For example: missing localizations, or using a faith trigger on a character. Crusader Kings…
-
bevy_ym2149_viz
Visualization systems for the bevy_ym2149 plugin (oscilloscope, spectrum, HUD)
-
macrogrid
work with grids in macroquad
-
phosph-rs
pretty, multiplatform molecular viewer for chemists
-
pasaka
Interactive fiction game engine
-
allegro_primitives-sys
Allegro 5 primitives addon Rust binding
-
bevy_vox_mesh
A bevy engine plugin for loading magica voxel files directly in bevy as usable meshes
-
catgirl-engine-utils
catgirl-engine crate
-
oxidized-registry
Block, item, and biome registries with O(1) state ID lookup and generated data
-
unen_app
Application crate for UnnamedEngine
-
mireforge-game-audio
Game audio
-
some_bevy_tools
A collection of tools which can be used in the Bevy Engine
-
bevy-realistic-crt
A Bevy post-processing plugin for CRT-style screen effects
-
rust-console-game-engine
Console game engine for Rust, heavily inspired by Javidx9's One Lone Coder Console Game Engine (https://github.com/OneLoneCoder/videos/blob/master/olcConsoleGameEngine.h)
-
bevy_web_keepalive
Bevy plugins to keep a bevy app running in the browser despite not being visible
-
impeller
Column-based protocol for transferring ECS data between different systems
-
bevy_ui_builder
ui builder library for bevy_ui
-
nimlib
Nim games: calculate nimbers and possible moves
-
astrelis-ecs
A high-performance Entity Component System (ECS) library for Rust
-
bevy_cached_query
high level query library for Bevy based on async tasks and Observer API very loosely inspired by TanStack Query
-
cranium-api
extending the Cranium AI library with utilities for using Cranium outside of Bevy as an AI Server
-
pixel-game-lib
AGPL licensed and opinionated game engine for pixel-art games
-
box2d-rs
Port of Box2d to Rust
-
bevy_mod_gba
Platform support for the GameBoy Advance with the Bevy game engine
-
tiles7800
a companion tool of cc7800 generating tiling data from Tiled maps
-
bevy_mod_scripting_qcvm
A QuakeC runtime for scripting Bevy games
-
gapp-winit
Abstract event loop library for winit-based applications with OpenGL and wgpu backends, integrating gapp traits for clean separation of input, update, render, and present
-
h_mat
A type-safe heterogenous matrix type
-
bevy_support_misc
My tiny common code to share between bevy game projects
-
bevy_webcam_facial
Webcam AI face recognition plugin for bevy game engine
-
bscore-lib
bowling score library for C (written in Rust)
-
plushy
Comfiest generational arenas for Rust
-
bevy_simple_i18n
Bevy i18n plugin
-
markdialog
Write your story with Markdown!
-
macroquad_ldtk
LDtk integration with macroquad
-
bevy_map_camera
3D Camera Controller for Bevy
-
bevy_mod_debug_console
Bevy plugin to use console to get information from ECS
-
zengine_ecs
ZENgine's entity component system
-
game-save-backuper
back up save data of some game server
-
wunderkammer
Entity-Component storage for tiny games
-
roguemap
Parser and renderer for procedural dungeon map generation in roguelike games
-
oml-game
Game foundation extracted from Fiiish-RS to remove boilerplate for future procjects
-
indigauge-types
Common types for indigauge protocol
-
box_intersect_ze
Broad phase collision detection using Zomorodian and Edelsbrunner's hybrid algorithm (streamed segment trees with pruning and scanning)
-
bevy_replicon_renet
Integration with renet for bevy_replicon
-
bevy_image
image types for Bevy Engine
-
quuidy
The simplest UUID v4 && v7 generation cli tool out there
-
souprune
A game framework designed specifically for Deltarune / Undertale fangames
-
bevy_mod_chroma
A plugin for the Bevy game engine to allow control of Razer Chroma devices
-
steam-vent-proto-steam
Protobuf structs used by the Steam client protocol for Steam
-
savesys
Variable-based save management system
-
neuton
A Game Engine for Rust on top of SDL2
-
bevy_ghx_proc_gen
Bevy plugins for 2D & 3D procedural generation with WFC/Model synthesis
-
udonsharp-bindings
Auto-generated bindings for VRChat, Unity, and C# APIs
-
crayon
A small, portable and extensible game framework
-
ascending_input
just a basic Library to help with winit input
-
argentum_game_coordinate_system
Argentum: Coordinate System
-
bevy_event_extras
Event utilities for the Bevy game engine
-
hot_potato
hot reloading library for development
-
eldiron-shared
Shared code and common types for the Eldiron applications
-
romesh
Rust parser for Roblox mesh files
-
bevy_state_curves
A state saving and management crate for the Bevy Game Engine saving via curve keyframes
-
hexglobe
generate hexagonal tessellations of a sphere quickly and accurately
-
bevy_splash_screen
A plugin for bevy which allows you to create screens to show the brands and development teams behind your amazing game
-
bevy_ios_alerts
Bevy plugin to request ios native UIAlert popups
-
roast2d
homebrew 2D game engine
-
bevy_procedural_grass
A plugin for bevy to generate grass
-
tx2-core
High-performance native ECS engine for cross-platform applications and games
-
machinery-api
Generated API types for The Machinery game engine
-
bevy_svg_map
load SVG to bevy, adding properties based on the style
-
firecore-battle
Pokemon battle simulation
-
wow-alchemy-wdt
Parser, validator, and converter for World of Warcraft WDT (World Data Table) files
-
pleco
A blazingly-fast chess library
-
bulb-parser
Parser and interpreter for Bulb Script
-
feo-oop-engine
An Object Oriented game engine for rust
-
mask_system_lib
(bevy_mask_system)A library for system architecture that utilizes functional programming principles to organize code. It primarily uses mask-based generics to structure systems.
-
bevy_more_shapes
Bevy engine plugin that adds additional shapes to the existing collection of procedurally generated geometry
-
hill_vacuum_shared
shared utilities among the other HillVacuum libraries
-
piston2d-graphics
2D graphics that works with multiple back-ends
-
bevy-vfx-bag
An assorted bag of visual effects for Bevy
-
bevy_webserver
A web server integration for the Bevy game engine that allows you to easily append a webserver to Bevy
-
aetheris-client-wasm
WASM browser client for the Aetheris multiplayer platform
-
sara_ecs
ecs library made for study purposes
-
bevy_ui_extras
containing a collection of utilities to make working with ui in bevy easier
-
glissile
A basic glam-compatible fixed-point math library
-
crow
A pixel perfect 2D rendering engine
-
cloudiful-bevy-settings
Reusable Bevy settings runtime for app-defined actions, field keys, and localization context
-
notation_guitar
Fun notation - definition for guitar
-
retrofire-geom
Additional geometry tools for retrofire
-
dorothy-ssr
The lib for building Dorothy SSR games in Rust running on target wasm32-wasi
-
inexor-rgf-rt
Inexor - Reactive Graph Flow - Application
-
soulsand-ai-api
AI agent API for Minecraft clients - perception system, action queue, agent trait
-
cargo-godot-lib
run Godot from a Cargo run script
-
dfhack-proto
Generated code from the DFHack API
-
dreamwell-gates
DreamGate — high-throughput Weave validation, batching, and dispatch for Dreamwell
-
rx_core_operator_composite
composite operator for rx_core
-
gdnative-bindings
The Godot game engine's automatcally generated bindings to Godot classes
-
planck_ecs
A tiny but very powerful ECS framework
-
chessie
Fast chess library, suitable for use in chess engines
-
bevy_mod_opacity
Hierarchical opacity for bevy
-
newport_math
Math library that also works with spirv shaders for Newport engine
-
bevy_puffin
Integration layer between Bevy, puffin and tracing
-
trs_24
An OpenGL-Powered Game Engine (OpenGL 2.0+)
-
nate-engine
Fun High Level ECS Game Engine I Wrote
-
bevy_easy_gif
Bevy crate for easy GIF spawning in your games
-
vizmat
visualize materials
-
limnus-assets
store assets in a slot map
-
lunex_engine
not inteded to be used standalone. It is a dependency of Bevy_Lunex
-
lunaris_ecs
Minimal ECS abstraction layer for Lunaris video editor - currently backed by bevy_ecs
-
bevy_retrograde_macros
macros used in Bevy Retrograde
-
qubic_engine
qubic engine
-
wow_spells
Spell definitions for World of Warcraft game servers
-
lpcg
A lib to generate character spritesheets based on LPC
-
replace_ident_in_expr
Replaces target ident with given ident in an expr
-
bevy_mod_clipboard
Bevy clipboard support plugin
-
oxyde-emotion
Plutchik-based emotion system for believable game NPCs
-
avila-optimizer
Mesh optimization: merge, LOD generation, spatial indexing - 100% Rust
-
suon_observability
Server observability and diagnostics for the Suon MMORPG framework
-
oml-audio
Very basic, and thin abstraction of audio handling meant for games
-
degen_toon_terrain
heightmap terrain plugin for Bevy game engine
-
usi
handle type-safe communication with USI-compatible shogi engines
-
parrot-rng
A lightweight, strictly deterministic procedural generation library for Rust
-
bevy_pixel_camera
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
fomod-oxide
FOMOD mod installer XML parser and evaluator
-
bevy_pins
A flexible pin/charm system for Bevy games, inspired by Hollow Knight's charm system
-
gravitron_utils
Gravitron's Utils
-
dces
DCES entity component system
-
playdate-sys
Low-level Playdate API bindings
-
oxidized_navigation
A Nav-Mesh generation plugin for Bevy Engine
-
ozz-animation-rs
runtime library for ozz-animation with cross-platform deterministic
-
bevy_cef_bundle_app
CLI tool to bundle CEF framework into macOS .app bundles
-
ltk_modpkg
League Toolkit mod package (.modpkg) reader/writer and utilities
-
neuro-sama
that implements the Neuro-sama game API
-
azalea-entity
Things related to Minecraft entities used by Azalea
-
raylib-sys
Raw FFI bindings for Raylib
-
bevy_cleancut
Random utility stuff for bevy for my personal use. You're welcome to use it, too, if you like.
-
bevy_text_animation
text animation library for Bevy
-
sbepistats
A Minecraft-inspired stat system for Bevy
-
bevy_mod_component_mirror
A bevy plugin to mirror components
-
mgf
A 3D collision and physics framework for video games
-
heavyli_engine
A game engine based on 'OpenGL'
-
evaluroll
A dice expression parser and evaluator
-
procmod-scan
Fast pattern and signature scanning for byte slices
-
bevy_skybox_cubemap
Cubemap-based Skyboxes for Bevy Engine
-
tego
loading Tiled maps
-
bevy_physimple
2d physics engine for bevy based on physme
-
blinds
Wrap an async abstraction over a window
-
bevy_gltf_save_load
Save & load your bevy games
-
bevy_gantz
A bevy plugin for gantz
-
oxygengine
Oxygengine
-
tts-external-api
External Editor API for Tabletop Simulator
-
cortenforge-vision-core
Core vision interfaces and capture/overlay helpers for the CortenForge stack
-
blackjack
popular casino card game Blackjack
-
gba_env
detecting the environment for GameBoy Advance ROMs (GBA/NDS/mGBA/VBA/gpSP/etc)
-
bevy_map_autotile
Tiled-compatible terrain autotile system
-
nage
Not Another Game Engine; command-line text adventure engine
-
bevy_text_popup
Easily create temporary text pop-up nodes in the Bevy game engine
-
bevy_mod_value_filter
A third party crate for bevy that enable value-based filtering
-
bevy_mod_scripting_functions
Necessary functionality for Lua support with bevy_mod_scripting
-
amethyst_physics
The Amethyst Physics engine interface
-
torchbearer
Find your path in darkerer dungeons
-
univis_ui_widgets
Built-in widgets for Univis UI
-
roblox-rs-core
Core compiler for translating Rust code to Luau for the Roblox platform
-
landmark
Navigation mesh generation from 3D triangle meshes
-
ra2-shp
Parser for Red Alert 2 shape files (*.shp)
-
uiactivity_ios_rs
Start a UIActivity on iOS from Rust code
-
bevy_spritesheet_editor
Editor for spritesheet defined with bevy_spritesheet
-
sonolus-models
High-performance, type-safe Rust models for the Sonolus rhythm game platform
-
bevy_easy_portals
Bevy plugin for easy-to-use portals
-
unreal_helpers
Tools for making and loading Unreal Engine Mods
-
paddle
2D Game Engine for Rust on the Web
-
rust_airport_supplier
Rust-AirportSupplier downloads airport data from OurAirports and decodes the information
-
devotee-backend-softbuffer
Softbuffer-based backend for devotee visualization engine
-
oxidized-client-headless
framework for headless Minecraft Java Edition clients — bots, testing, and automation
-
tgr
Игровой движок на Rust
-
bevy_dither_post_process
A post-process black and white ordered dithering effect for the Bevy game engine
-
byond
interfacing with the BYOND game engine
-
ugli-raw
Game ENGine
-
limnus-wgpu-math
wgpu math types
-
aws-gamelift-server-sdk-rs
AWS GameLift Server SDK for Rust
-
vbsp-entities-tf2
VBSP entity definitions for Team Fortress 2
-
axle_ecs
Axle's entity component system
-
bevy_rig
Bevy ECS primitives and systems for modeling providers, agents, tools, sessions, runs, and workflows on top of Rig
-
aetheris-ecs-bevy
Bevy ECS integration for the Aetheris Protocol
-
kira_framework
OneBot 11 based on the ECS architecture
-
recs
flexible, macro-free entity-component system in pure (stable!) Rust
-
seldom_map_nav
Bevy plugin that does navmesh generation, pathfinding, and navigation for tilemaps. Navmesh generation is available without Bevy dependency.
-
bevy_intro_screen
Highly customizable introductio n(splash) screen library for Bevy games
-
bevy_shuffle_bag
shuffling collections in Bevy
-
wecs
ECS lib for general use
-
bobox214/kataster
A beginner-friendly single screen space shooter developed in Rust with 'bevy'
-
godot-properties-parser
A parser for Godot Engine property files (.tscn scenes and .godot projects)
-
burn_dragon_fovea_viewer
Foveation viewer for burn_dragon vision sampling
-
sable-build
Build system and asset pipeline for the Sable engine
-
ecs-tiny
A minimal ECS supporting entity and component insertion/removal, association, and single-type iteration
-
mini_asset_loader
A composable game asset-loading system
-
orbtk
The Orbital Widget Toolkit
-
mevy_ecs_syntax
token handling for mevy_ecs!
-
aerox_network
AeroX 网络层抽象和协议实现
-
limnus-gamepad
Platform independent gamepad management
-
spin_sleep_util
Utils using spin_sleep
-
panik
Application-wide panic handling, whereby panics occurring in any thread are treated as a hard error and can be detected by other threads to trigger a graceful exit
-
bevy_proto
Create config files for entities in Bevy
-
macademia
A realtime application/game engine written in rust
-
uobors_cli
Unleash OpenBOR modding in Rust
-
playdate-system
High-level System API built on-top of Playdate API
-
oxyde-intent
Intent classification for NPC interactions
-
amethyst_tools
Game development tools for the Amethyst engine
-
resonance
A modular game engine. Heavy work in progress.
-
bracket-geometry
Geometry utilities. Rect, lines, circles, distance calculations. Part of the bracket-lib family.
-
hive-engine
A game engine for Hive
-
bevy_typst_textures
Resource for generating rasterized textures out of either standalone .typ files or structured, zipped typst projects, built on typst-as-lib
-
pagurus
Ultra-portable game engine suited for offline 2D games powered by WebAssembly
-
bevy_registration
Run code on the app from far away
-
suon_chunk
World chunk and map-grid primitives for the Suon MMORPG framework
-
forky
Rust Utilities
-
space-partitioning
Space partitioning data structures
-
bevy-discord-presence
Discord presence plugin for the Bevy game engine
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
perovskite_game_api
Multiplayer voxel game written in Rust - default game content + plugin API
-
multibuffer
implementing triple buffering and generalized multi-buffering patterns
-
intrepid
Manage complex async business logic with ease
-
notan_egui
EGUI support for Notan
-
botw-utils
various utilities for modding Breath of the Wild
-
mtnrust
start for rust publish done by Metin Ilhan, will be improved later
-
nightrunner_lib
A parser library for making text adventure games
-
bevy_show_prepass
A Bevy plugin to visualize depth, normal and motion vector prepasses
-
varion
텍스트 기반 DSL로 구성된 대화 시스템 파싱 라이브러리
-
oxide-core-transform
Oxide Core transform and hierarchy primitives
-
glfw-ext
GLFW utilities and extension methods
-
voxelis
Sparse Voxel Octree DAG engine for building worlds, shaping matter, and mastering 3D space — powered by pure Rust
-
serde_vrm
Serde types for VRM
-
valve_pak
CLI tool for reading and writing Valve Pak files
-
benthic_ui
Bevy UI plugin for open metaverse clients
-
bevy_ecs_typewriter
ECS typewriter system for Bevy engine
-
bitt
Bevy integration testing toolkit
-
uika-runtime
Safe Rust runtime for uika (object refs, lifecycle, dynamic calls)
-
dbsdk-cli
Command-line utility to simplify building Rust games for the DreamBox fantasy console
-
notan_web
web/wasm32 backend for Notan
-
bracket-noise
Rust port of Auburn's amazing FastNoise library. Part of the bracket-lib family.
-
bevy_oxr
Community crate for OpenXR in Bevy
-
bevy_mod_krita
Use Krita's .kra files directly in your Bevy app
-
aeronet_io
IO abstraction primitives for
aeronet -
bevy-wicon
A tiny Bevy plugin to set a window icon
-
aery
Non-fragmenting ZST relations for Bevy
-
cogs-gamedev
Common, Obnoxious Game Stuff. Contains a bunch of useful boilerplate for writing games.
-
tttm
Tic Tac Toe game with a Menace AI
-
woodpecker_ui
A UI library for the Bevy game engine
-
bevy_persist
Automatic persistence for Bevy resources with change detection
-
libmancala
A frontend-agnostic library that implements the game of Mancala
-
bevy_web_file_drop
Bevy plugin adding better support for drag and drop files in the web
-
salva2d
2-dimensional particle-based fluid dynamics in Rust
-
gaymwtf-core
A modular 2D game engine and framework built with Rust and Macroquad
-
dds-bridge-sys
Generated bindings to DDS, the double dummy solver for bridge
-
hotham
A framework for creating incredible standalone VR experiences
-
ryot_ray_casting
Implements ray casting capabilities for Bevy, crucial for interactive game mechanics like line-of-sight, fog, complex collision, etc
-
press_here
modular input handling for Bevy
-
nphysics_testbed3d
Testbed for the 3-dimensional physics engine in Rust
-
gdnative-async
Runtime async support for godot-rust
-
bevy_ui_styled
function that let’s you define a bevy_ui
Stylecomponent withtailwindcssinspired syntax -
limnus-system-state
Keeps the state that is provided to systems
-
bevy_mod_sysfail
Decorate your bevy system with the sysfail macro attribute to handle failure
-
rbp-cards
Card representation, hand evaluation, and strategic abstraction primitives
-
event-simulation
event based simulation of application state
-
tetris_core
Tetris game model with no UI or Game engine
-
bevy_tiled_background
A Bevy plugin for creating tiled, animated UI backgrounds with rotation, staggering, and scrolling
-
pretty_text_parser
Parser for Bevy Pretty Text
-
scml
Parser and skeletal animation evaluator for Spriter SCML files
-
bevy_diesel
A generic ability engine framework for Bevy
-
bevy-yoetz
A decision-making AI for the Bevy game engine
-
eu4save
Ergonomically work with all EU4 saves (ironman and multiplayer)
-
gorrosion-gtp
A best-effort strongly typed interface between Rust and GTP, the Go Text Protocoll
-
hexga_engine
A multimedia game and software engine for handling graphics, audio, and input
-
dou_dizhu
Rust toolkit for the Chinese card game Dou Dizhu (斗地主)
-
bevy_trauma_shake
A plugin for shaking 2d cameras
-
xwebtransport
A common WebTransport interface for browser and native. Write once, run anywhere. Originally intended for use with bevy.
-
bevy_dev
Dev tools for Bevy Engine
-
sursface
Small cross-platform rendering library
-
bevy_scrollbar
Bevy plugin providing a scrollbar
-
vrc
Unofficial rust types of VRChat's API
-
game-dev-tools
Reusable Bevy game development utilities for 2D games
-
bevy_filter_enum
Derive marker components from enum variants for Bevy ECS queries
-
bevy_slinet
networking plugin for bevy
-
gridit
2D grid library utilizing the fun of iterators
-
ambient_guest_bridge
Ambient runtime that allows code to target either native host code or the API exposed to guest code
-
gravita-renderer
Minimal CPU-based 2D rendering utilities for prototyping and simple games
-
sanqi-render
ASCII and SVG rendering helpers for the Sanqi board game
-
bevy_interleave_interface
interface for e2e packed to planar bind groups
-
bevy_dioxus_desktop
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
kusa_pixel
A pixel art painter for people who are sick of GUIs
-
anvilkit-render
Cross-platform rendering system built on wgpu and winit for AnvilKit game engine
-
treasury-server
Treasury server
-
bevy-egui-notify
notifications library for EGUI, in the bevy system
-
seldom_fn_plugin
Allows using Rust functions in place of Bevy plugins
-
amethyst/space-menace
An action 2D platformer made with Amethyst game engine
-
bimifc-bevy
Bevy-based 3D viewer for IFC models with WebGPU/WebGL2 rendering
-
bevy_eventwork_mod_websockets
A Websocket NetworkProvider for Bevy_eventwork
-
hephae
A personalized, opinionated Bevy plugin that adds support for drawing and batching arbitrary vertices and indices
-
bevy-aabb-instancing
Render millions of AABB instances in Bevy
-
bevy_spritefusion
A Bevy plugin for loading Sprite Fusion tilemap exports
-
froql
an in memory query dsl
-
fontmesh
Pure Rust library for converting TrueType font glyphs to 2D/3D triangle meshes
-
bevy_fog_of_war
A 2D fog of war plugin for Bevy
-
mun_runtime_capi
C API for the Mun runtime
-
grid_util
primitive constructs like Grid, Point, Rect, etc
-
mesh-tools
generating 3D meshes and exporting them to glTF/GLB files
-
legion-systems
High performance entity component system (ECS) library
-
happy_feet
Character movement for the bevy game engine, using avian3d for physics
-
bevy_hou
Bevy ↔ Houdini integration plugin
-
ABC_Game_Engine
fast, and flexible Game Engine written in Rust, with simplicity in mind
-
coffee
An opinionated 2D game engine focused on simplicity, explicitness, and type-safety
-
crystalorb
Network-agnostic, high-level game networking library
-
bevy_verlet
Verlet physics implementation in bevy
-
bevy_dolly
The dolly abstraction layer for the bevy game framework
-
rovella
A game library that, at present, only consists of a windowing and events wrapper
-
sophon
a game framework,support micro service
-
pecs
Asynchronous operations for Bevy Engine
-
arcade_jump
Arcade jump trajectory configurator
-
bevy_logic
A logic gate simulation plugin for Bevy
-
ayaka-plugin
Plugin runtime interface for Ayaka
-
we_clap
Web Enabled Command Line Argument Parser
-
bevy_app_compute
An easy way to run compute shaders for Bevy
-
chiploxide
(todo) mystery, challenges, games, an ide 👁️🗨️
-
cloudiful-bevy-outline
Reusable geometry-shell outline plugin for Bevy
-
limnus-loader
Loads assets for limnus
-
bevy_old_tv_shader
An "old TV" post-processing effect
-
bevy_tiled_prototype
A plugin for rendering tiled maps
-
bevy_cursor
A bevy plugin to track information about the cursor
-
modde-core
Core types and logic for the modde mod manager
-
bevy_customizable_camera_controllers
Customizable camera controllers for Bevy
-
rsaber_android
rsaber
-
jengine
Personal roguelike game engine
-
wrapped2d
Rust binding for Box2D
-
emf-core-base-rs
Idiomatic Rust wrapper of the emf-core-base interface
-
journey-engine
Journey Engine: A custom 2D game engine built with Rust and wGPU
-
bevy_gamepad
Apple Game Controller Framework Integration plugin for Bevy
-
bevy_hookup_messenger_steamworks
The steamworks messenger of the bevy_hookup library
-
simple_event_bus
A basic, simple event bus in Rust
-
nemu
An interactive story engine for creating text-based adventure games
-
turbo_atlas_icons
A system for declarative ui icon rendering with Bevy
-
bevy_spicy_networking
A spicy 🌶🌶🌶 and simple networking plugin for Bevy
-
oxide-core-math
Oxide Core math - glam-based math types for game development
-
rafx-api
Rendering framework built on an extensible asset pipeline
-
bevy_map_schema
Schema validation for bevy_map_editor entity types
-
hammerspace
A plugin for the loading and management of levels and scenes, and their physical properties
-
chess-engine
A dependency-free chess engine library built to run anywhere
-
bevy_cube_marcher
A shader-based marching cubes implementation for Bevy
-
rect_packer
A rectangle packing library. Heavily tested with random data to ensure that it always produces correct result.
-
bevy_xpbd_3d_parenting
Allows children of a
bevy_xpbd_3dRigidBodyto exert forces on their parents -
gfx_smaa
post process antialiasing using SMAA
-
pico-engine-shell
Runtime shell for Pico Engine games
-
xplane
High-level interfaces to the X-Plane plugin SDK
-
ta-connector-unity
Unity Engine connector for Trusted Autonomy
-
team-plover/warlocks-gambit
The Bevy Jam 1 Team Plover game submission
-
jugar-render
Rendering system for Jugar with responsive camera
-
ramirezmike/not_snake
A snake-inspired game made in Rust using the Bevy game engine
-
astrelis-scene
Astrelis Scene Module
-
pixel-handler
Wrapper for the ggez game engine crate
-
distill
Asset framework for game engines & editor suites
-
forsyth
A pure Rust implementation of Tom Forsyth's 'Linear-Speed Vertex Cache Optimisation'
-
bevy_mod_spritesheet
Create TextureAtlasLayouts from common sprite sheet formats
-
bevy_mistUI
Procedural mist and smoke-ring borders for Bevy UI
-
despero-hecs-schedule
shedulable systems and parallel execution for hecs
-
devotee-backend
Backend library specification for the devotee project
-
pixel8bit
applying 8-bit pixelation effects with symmetry detection and mirroring
-
notation_model
Fun notation - runtime models
-
bevy_tray_icon
Allows the use of tray-icon to manipulate the system tray
-
bevy_auto_plugin_nightly_shared
shared lib for bevy_auto_plugin that require nightly rust
-
bevy_sparse_grid_2d
Wrapper around a 2d hash map made for collision broadphase
-
bevy_third_person_camera_2
flexible plugin for Bevy game engine
-
ege
Small easy to use game engine
-
lueur
Shadowy game and graphics library for Rust
-
three
Three.js inspired 3D engine in Rust
-
input-actions
An input system for binding PC & Gamepad inputs to application actions
-
bevy_fluent
Bevy plugin for localization using Fluent
-
bevy_sepax2d
Plugins and helpful methods for using sepax2d with Bevy for 2d overlap detection and collision resolution
-
raycaster
A multi-threaded raycaster engine for creating game graphics similar to Wolfenstein3D
-
bevy_pretty_nice_input
An action- and component-based input crate for Bevy
-
ggegui
egui for ggez
-
wgsl_preprocessor
An unofficial preprocessor for WGSL written in Rust for WGPU
-
arcane-engine
Arcane game engine — agent-native 2D engine with embedded TypeScript runtime
-
bevy_mouse_tracking_plugin
A plugin for effortless mouse tracking in the bevy game engine
-
bscore
bowling score library for Rust
-
gecs
A generated entity component system
-
deckbuilder_eng
A modular engine for deck-builder games with egui UI, audio, and card/deck/game logic
-
bevy_state_scoped_resources
State-scoped resource lifecycle management for Bevy — the resource equivalent of StateScoped
-
kludgine
A wgpu-powered 2d graphics library with optional windowing support
-
bevy_map_scatter
Bevy plugin that integrates the
map_scattercore crate for object scattering with field-graph evaluation and sampling -
game_clock
clock for game (engines) that is simple to use and efficient
-
vulkan-registry
Parses the Vulkan API Registry XML files
-
specs-task
Fork-join multitasking for SPECS ECS
-
bevy_tmx
Scene loader for .tmx files created by the Tiled map editor
-
distance-field
Generate distance fields from images for pseudo-vector rendering
-
houtamelo_utils_gdnative
A collection of utilities shared between Houtamelo's GDNative projects
-
bevy_term
Easy terminal event handling and rendering with Bevy!
-
quaturn
A 3D game engine written in Rust
-
libmarathon
A peer-to-peer game engine development kit with CRDT-based state synchronization
-
oj_serdes
Serializable API types for OpenJam servers
-
fyrox-autotile
An autotiler for Fyrox game engine
-
yarnspinner_compiler
Compiler for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
bevy_actify
An input action plugin for Bevy
-
stockton-bsp
parsing Q3 .bsp files
-
bevy_quill
A reactive UI framework for Bevy
-
sge_textures
Texture related functionality for SGE
-
rscenes
Scenes manager for Raylib
-
massive_game_server_protocol
Shared FlatBuffers protocol crate for massive_game_server
-
bevy_crab_networking
Bevy plugin for sending data over TCP
-
bevy_landmass
A plugin for Bevy to handle navigation of AI characters
-
rein
rein 3D Rendering Library
-
bevy_pretty_text
Text effect library for Bevy
-
turbine
3D game engine for content production
-
inexor-rgf-model-http
Inexor - Reactive Graph Flow - Model - HTTP
-
voxquant_dotvox
A program to convert triangle meshes to voxels
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
game4all/vx_bevy
🧊 Voxel engine prototype made with the bevy game engine. Serves as a playground for experimenting with voxels, terrain generation, and bevy.
-
reversi_client_rust
A client for the Reversi game server used in BYU CS 470
-
ivy-collision
3D collision crate for Ivy
-
bevy_simple_rich_text
A tiny rich text helper for Bevy
-
rmf_site_egui
Barebones bevy_egui widgets for the rmf_site_editor
-
chikage
easy to understand and barebones math library for game and graphics development
-
bevy_blender
Bevy library that allows you to use assets created in Blender directly from the .blend file
-
bevy_mod_raycast
Ray Casting for the Bevy Engine
-
bevy_curvo
NURBS modeling plugin for Bevy
-
wutengine
A modern game engine
-
unreal_asset
Unreal Engine 4/5 game asset serialization library
-
bevy_asepritesheet
Allow use of animated exported asetprite sprite sheets in bevy game engine
-
amico-core
The core Agent components of the Amico AI Agent Framework
-
libfar
interacting with FAR archives
-
rvne
A high-performance visual novel engine written in Rust
-
otter-base
Otter game system; WASM/hostside common code crate
-
orbit_input_core
Core trait protocol for Orbit Engine's input system — provides unified, platform-agnostic abstractions for keyboard states and runtimes
-
moirai-bevy
Moirai plugin for Bevy game engine
-
gdnative_bindings_generator
Generates bindings for the Godot engine's gdnative classes from a json api description file
-
poirebot
A chess bot engine written in Rust
-
serde_sbin
Serialize Binary
-
obel_dylib
Force the obel Engine to be dynamically linked for faster linking
-
olc-pge
A reimplementation of the olcPixelGameEngine in Rust
-
keeshond_treats
Easy building blocks for Keeshond so you can start making your games sooner
-
overworld
Metapackage library for adding game systems useful for incremental, RPG, and management games
-
bevy_fabrik_solver
A Fabrik based IK Solver for the Bevy game engine
-
bevy_dexterous_developer_library
A modular hot reload system for rust
-
mathtools
fast 2D/3D/4D math library for graphics and games
-
bevy_window_utils
window utils such as managing window icon and taskbar progress indicator in Bevy
-
bevy_text_mesh
A bevy 3D text mesh generator for displaying text
-
spritesheet-generator
A spritesheet generator library using the piston's texture_packer
-
ivy-resources
Handle based resource management and shared state
-
hydrate
Game asset pipeline and authoring framework
-
bevy_power
A comprehensive power/energy system for Bevy games with regeneration, limits, knockouts, leveling, and UI components
-
gerrymander
Push-down state automata for games
-
mortar_language
A Domain Specific Language designed for game dialogue and text event systems
-
rekt-protocol-common
Common lib to use the rekt-protocol. See the crate homepage to check the protocol RFC.
-
bevy-rrise
A Wwise Bevy integration
-
bevy_dlc_macro
Procedural macros for bevy-dlc
-
iyes_scene_tools
Extra helpers for working with Bevy Scenes
-
curseofrust-cli-parser
CLI arguments parser for curseofrust
-
bevy_ratatui_render
A bevy plugin for rendering your bevy app to the terminal using ratatui
-
gate
A specialized 2D game library
-
mod_plugins_resources
Reduce plugin boilerplate in the Bevy game engine
-
bevy_picking_state_machine
A global state machine for working with
bevy_picking -
bevy-tnua-avian3d
Avian 3D integration for bevy-tnua
-
bevy_ratepace
bevy_ratepaceis a crate to configure the update frequency of headless bevy -
bevy_gltf_components
Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side
-
wow_items
Item definitions for World of Warcraft game servers
-
baryon
Fast prototyping 3D engine
-
wutengine_editor
editor for WutEngine games
-
smol-layout
a small layout utility for very simple pixel art games
-
schafkopf-logic
Logic and rules for the Schafkopf card game: deck, suits, ranks and game modes
-
bevy_many_relationships
A Bevy plugin for many-to-many relationships between entities
-
cranium-bevy-plugin
extending the Cranium AI library with a Plugin for quick and easy integration
-
unity-unpacker
A CLI utility for unpacking the assets from Unity's .unitypackage file
-
arimaa_engine_step
A step based engine for the board game Arimaa
-
charge
Modern, minimal, efficient Vulkan game engine
-
seeded_dice_roller
A dice roller using a seed to give deterministic results
-
bracket-terminal
ASCII/Codepage 437 terminal emulator with a game loop. Defaults to OpenGL, also support WebGPU (for Vulkan/Metal/WGPU), Curses and Crossterm for output. Part of the bracket-lib family.
-
modulator
A trait for abstracted, decoupled modulation sources
-
localgpt-cli-tools
LocalGPT CLI tools — bash, read_file, write_file, edit_file
-
bracket-state-machine
State management library for bracket-lib terminal
-
bevy_cuda
CUDA integration for Bevy game engine
-
catgirl-engine-server
Server side part of the catgirl-engine crate
-
bevy_sorting
Sorting bevy systems based on reads and writes
-
ftw
A CLI tool to manage your godot-rust projects!
-
gl-from-raw-window-handle
creating an OpenGL context from a RawWindowHandle
-
stockfish
Light, easy-to-use wrapper for the Stockfish engine
-
bevy_mod_scripting_bindings
Core traits and structures required for smoothly interfacing with other languages in a generic way
-
ivy-vulkan
Low level vulkan abstractions for the Ivy game engine
-
aline
2d linear algebra library suitable for no_std
-
giga-chess
chess library built for performance, handling game logic and legal/best move generation
-
bevy_crossterm
Develop terminal games with crossterm and Bevy
-
procmod-hook
Inline function hooking and detouring for x86_64
-
bevy_quickmenu
way of quickly creating nested menus in bevy that can be navigated with keys, gamepads and pointers
-
piston
game engine core libraries
-
bevy_gearbox_protocol
Protocol (client/server) for Bevy Gearbox editor/app communication
-
hewn
game engine built for educational purposes
-
chaos-framework
Game framework for creating games!
-
perigee
A headless realtime 3D engine built with a focus on the web
-
bevy_fsc_point_cloud
Point cloud renderer for Bevy
-
ry-stream
LAN streaming server with WebSocket + embedded web portal for the Ry-Dit game engine
-
bbggez
functions by the Brooks Builds community for the Rust game engine GGEZ
-
aamp
Nintendo parameter archive (AAMP) files
-
spacetime_tiled
SpacetimeDB integration for loading Tiled map editor files
-
sisyphus32
Feature-based UCI Chess Engine
-
unity-native-plugin-sys
-
bevy_pbr
Adds PBR rendering to Bevy Engine
-
ck3save
Ergonomically work with all CK3 saves (regular and ironman)
-
bevy_simple_preferences
Preferences API for Bevy
-
bevy_query_service
that helps with querying components as a service in Bevy
-
bevy_ios_review
Bevy plugin for to request ios native review API from within the App
-
bva_cli
Bevy Vach Assets CLI
-
bevy_impulse
Reactive programming and workflow execution for bevy
-
repath
A fast pathfinding library using A* algorithm, caching, precomputation and path segmentation with concurrent pathfinding
-
kifuwarabe_tic_tac_toe
A small example before developing computer chess and computer shogi. Come see the repository.
-
dummy-agones
Dummy Agones SDK server for developing Agones integrations
-
qwac
Rust client crate for making qwac games
-
bevy_blendy_cameras
Bevy editor like cameras controls for Pan/Orbit/Zoom and Fly mode. Switch mode, set camera viewpoint and frame view around entities
-
keket-client
Asset server client fetch engine for Keket toolkit
-
steamworks-encrypted-app-ticket-sys
Low-level bindings for Steam's sdkencryptedappticket
-
puzzle_design
A game engine for generic puzzle design and problem solving
-
godot-binary-serialization
A Godot binary serializer to encode & decode types from & to godot
-
famiq
Experimental GUI library, powered by Bevy engine
-
keeshond
A fast and fun 2D game engine for Rust
-
gm-ffi
an interface between GameMaker and Rust
-
gdenv
The best command-line tool to install and switch between multiple versions of Godot
-
bevy_symbios_ground
Bevy integration for an algorithmic terrain engine
-
bevy_mod_kira
A plugin that integrates the Kira audio library for use in the Bevy game engine
-
bevy_auto_timer
Bevy plugin for convenent timer
-
bevy_simple_prefs
A small Bevy plugin for persisting multiple Resources to a single file
-
moonshine-util
Collection of utilities for Bevy
-
boxdd-sys
Low-level FFI bindings for Box2D built from upstream via submodule
-
bevy_lospec
Asset loader plugin for Bevy that adds support for lospec color palettes
-
rydit-anim
Animation module for RyDit - Easing functions, Squash & Stretch, Disney principles
-
bevy_tileset_map
An extension to bevy_ecs_tilemap, allowing for configurable tilesets, auto tiling, and more using the bevy_tileset crate
-
bevy_window_reveal
A Bevy plugin for controlling the initial visibility of the game window, allowing you to hide the window at startup and reveal it after a specified number of frames or milliseconds
-
gamemath
math library for game development, written in Rust
-
adam_fov_rs
Adam Milazzo's FOV algorithm http://www.adammil.net/blog/v125_Roguelike_Vision_Algorithms.html#mine
-
bevy_retro_ui
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
pawkit
mninimal game engine toolkit, written in Rust, with support for C, C++, Godot, and Lua
-
ecs
An Entity Component System (ECS) Framework
-
bevy_aquila
Aquila server bevy plugin
-
nitron-bevy
Create native UIs in Rust
-
kengaai-fps
The core FPS rendering and logic crate for the KengaAI Engine
-
dreamwell-matter
DreamMatter benchmark — GPU physics materialization demo and profiler
-
bevy_channel_message
Send events via a channels form anywhere (eg. c-ffi) to Bevy (buffered) messages.
-
bevy_mod_transform2d
A 2D Transform component for The Bevy game-engine
-
schematic-mesher
Generate 3D meshes from Minecraft schematics and block data
-
chess-oxide
A chess engine library written in Rust, with a GUI bin to play against it
-
bevy_hookup_messenger_self
The self messenger of the bevy_hookup library
-
wow-alchemy-adt
Parser for World of Warcraft ADT terrain files with heightmap and texture layer support
-
bevy_serialization_core
contains the plugins/systems that bevy_serializations_extras relies on, + some misc wrappers
-
rx_core_operator_throttle_time
throttle_time operator for rx_core
-
bevy_coroutine_system
A coroutine system for Bevy game engine
-
bevy-butler
making Bevy systems more self-documenting
-
slender-math
Lightweight math library for game development
-
sge_texture_atlas
Texture atlas type for SGE
-
univis_ui_interaction
Interaction and picking backend for Univis UI
-
navmesh
NavNet, NavGrid, NavFreeGrid and NavIslands navigation system
-
uobors_core
Unleash OpenBOR modding in Rust
-
bevy_btml
A macro to create Bevy entity-component hierarchies using an HTML-like syntax
-
rsanim
A basic state machine for managing sprite animations
-
kit
An small game engine for 3D games
-
jugar-apr
Aprender Package Resource (.apr) model format for AI game behaviors
-
dexterous_developer_dynamic
A modular hot reload system for rust
-
magma_windowing
Part of the Magma-API, which is the API of the Magma3D game engine. This is responsable for handling windows.
-
recompose
Declarative framework for the Bevy game engine
-
image-atlas
A texture atlas generator for generic purpose
-
dialogos
A super simple dialogue system for Rust
-
suon_position
Position and coordinate types for the Suon MMORPG framework
-
glacier-texture
Read and write Glacier Texture files
-
lib-hearts
Basic Implementation of the hearts card game
-
bevy_compute_noise
A Bevy plugin for generating tilable 2D/3D noise textures using compute shaders
-
beet_parse
Parsers for various text and token formats
-
pure_rng
rand-compatible RNG library for generating repeatable, controlled random values, designed primarily for use in games
-
thot-pocket
Eye contact intelligence for AI avatars — the missing layer between seeing and connecting
-
bevy_material_wizard
A material replacement utility for bevy
-
comfy
2d game engine in Rust
-
jugar-ai
AI systems for Jugar using Aprender backend
-
bevy_xray_parser
Parse Bevy source code to extract state hierarchies, plugin dependencies, and schedule configurations
-
mage-core
An ASCII art game engine written in Rust
-
bevy_fabulous
A Bevy plugin for enriching spawned GLTF scenes with gameplay components / assets
-
cute-dnd-dice
roll dices
-
chessai
High-performance Xiangqi (Chinese Chess) AI engine with u128 bitboards
-
bevy_telemetry
bevy swarm diagnostic, event, metric, and telemetry client
-
pybevy_image
Image asset for PyBevy
-
shadow_engine_2d
A modern, high-performance 2D game engine built in Rust with ECS, physics, particles, audio, and more
-
bevy_egui_next
A plugin for Egui integration into Bevy
-
moore-neighborhood
Calculates Moore neighborhoods (8-connected) for arbitrary ranges and dimensions
-
bevy_mod_gizmos
Visual gizmos to aid with development and debugging in Bevy
-
tdlg
Generates a grid of cells that could be used to build a top-down game map. Used by me to learn Rust.
-
ecs_rust
ECS in Rust
-
deckofcards
An API to implement a deck of cards
-
kayak_ui
A UI library built using the bevy game engine!
-
bevy_mod_pies_spacetraders_api
SpaceTraders API implemented for Bevy the game engine
-
pocket-relay-mitm-server
Pocket Relay Redirector server used to proxy clients to the main server while logging traffic
-
lightyear_interpolation
IO primitives for the lightyear networking library
-
thephet/bevyroguelike
Roguelike game using Rust and the Bevy engine
-
rantz_proto
An opinionated rust library for transforming on-disk assets into Entities in Bevy
-
libchessticot
A chess library with engines
-
valence
A framework for building Minecraft servers in Rust
-
rokol
Rust bindings to Sokol
-
bevy_retrograde
Pixel-Perfect, 2D Renderer and plugins for Bevy that Seamlessly Targets Desktop and Web
-
rmf_site_picking
Picking utilities and workflows for rmf_site_editor
-
aquila_client
Aquila server client
-
luminol-web
Web-specific code for running Luminol
-
bevy_embedded_assets
A Bevy plugin to embed assets in your game
-
yuxii
ECS-based 3D game engine
-
maikklein/unreal-ffi
Rust integration for Unreal Engine 5
-
ayaka-model
Ayaka high-level runtime
-
bevy_icon_creator
A plugin to automatically create Icons from entities/models in bevy
-
fyrox-scripts
Standard scripts for the Fyrox engine
-
bevy_quill_overlays
Reactive, translucent overlays
-
anvilkit-assets
Asset system with glTF model loading for AnvilKit game engine
-
sdl2-sys
Raw SDL2 bindings for Rust, used internally rust-sdl2
-
xuko-ecs
xuko's ECS implementation
-
lumenpyx
A 2D pixel art renderer with realistic lighting
-
moonshine-spawn
Collection of tools for spawning entities in Bevy
-
bevy_ambient_cg
Bevy Plugin for importing materials from https://ambientcg.com/
-
perovskite_server
Multiplayer voxel game written in Rust - Game server
-
limnus-system-params
Limnus system parameters
-
firefly-ui
UI helpers and components for Firefly Zero system apps
-
entity_table_realtime
An ECS data store for realtime components
-
tinystorm
but powerful framework designed primarily for building simple testing low-level games
-
bevy_expected_components
Runtime validation for Bevy component dependencies
-
bevy_spawn_observer
Add observers to your bundles
-
game_board
A rectangular game board of squares, for use in games like chess or checkers
-
bevy_pathfinding
3D Bevy plugin that combines flowfield pathfinding with boid-based collision avoidance to move units smoothly. Great for RTS games!
-
brick_bird
A colorful Flappy Bird clone written in Rust. Cross platform. Has own physic engine. Parallel.
-
tokyodoves
efficient board of Tokyo Doves and associated toolkits
-
forky_play
Rust Utilities
-
rantz_spatial2d
A set of 2D spatial utilities for Bevy, including handling transform propagation
-
uci-parser
Universal Chess Interface parser
-
bevy_editor_pls
In-App editor tools for bevy apps
-
waymark-dynamic
Dynamic navigation mesh generation for Landmark and Waymark
-
rx_core_testing
tools for testing rx_core
-
ryot
MMORPG library based on the concepts of open tibia written in rust and bevy
-
kira_qqbot
KiraFramework proc macro
-
bevy_scoreboard
A very simple scoreboard plugin for Bevy
-
cvars-console
In-game console using the cvars crate for configuration - internal crate, use cvars-console-fyrox or cvars-console-macroquad in your game
-
devu
A fast, minimal, and ergonomic entity-component-system library
-
late-java-core
launching Minecraft Java Edition
-
tehuti-mock
Mock testing engine for Tehuti communication system
-
eldiron-creator
A game creator for classical RPGs
-
treasury-api
API for treasury server
-
bevy_veilid
Build turn-based p2p games with Veilid
-
bevy_flurx_api
api plugins for bevy_webview_wry
-
creator-permissions
Mobile Game Framework
-
limnus-resource
resource container
-
rhusics
Physics library for use with
specs -
bevy_tiling_background
A plugin to make tiling, layered, and parallax backgrounds for bevy2D
-
imperator-save
Ergonomically work with Imperator Rome saves (debug and ironman)
-
fluffl
A cross-platform multimedia layer that exposes opengl,sockets,and audio utilities for desktop and browser
-
playdate-display
High-level Display API built on-top of Playdate API
-
bevy_rpack
Bevy plugin with rpack atlas support
-
bevy_spine
Spine plugin for Bevy utilizing rusty_spine
-
waymark-tilecache
Dynamic obstacle management and tile caching for navigation meshes
-
libktx-sys
Rust bindings for libktx
-
bitshifter/mathbench
Comparing performance of Rust math libraries for common 3D game and graphics tasks
-
schminput_rebinding
Input Rebinding for Schminput
-
yarnspinner_runtime
Runtime / VM for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
bevy_toon_shader
Toon shader for the Bevy game engine
-
bevy_auto_system_macro
A macro for making bevy system queries more convenient
-
naia-bevy-client
faciliate naia_client & Bevy interop
-
maikor-vm-core
VM for playing Maikor games
-
xanadu
A toy ECS library
-
chess-move-gen
Fast chess move generation library. Uses SIMD for fast sliding piece move generation
-
bevy_submerge_ui
A ui plugin with tailwind like capabilities for bevy
-
vulk-test
Vulkan bindings for Rust, except only the bleeding edge features
-
nova-r8
comprises Rust bindings for the Nova r8 game engine
-
limnus-screen
platform neutral screen and window types
-
ren
easy to use graphics library
-
murk-core
Core types and traits for the Murk simulation framework
-
tf-asset-loader
loading assets from tf2 data files
-
soulsand-registry
Dynamic registry system for Minecraft data - load blocks, items from JSON manifests
-
macroquad-tiled
Tiled editor macroquad intergration
-
open-oak
2D game engine and rendering library
-
oxidized-chunks
Chunk data structures — LevelChunk, PalettedContainer, BitStorage, Palette, Heightmap
-
bevy_mod_ffi_host_sys
Low-level FFI bindings for bevy_mod_ffi hosts
-
fyrox-dylib
Dynamic library for Fyrox Game Engine
-
bevy_ui_anchoring
A small bevy plugin for anchoring UI elements to specific points or entities in the world
-
dev_menu
in-engine developer menu library
-
bevy_scene_postprocess
Bevy that provides a way to postprocess scenes after loading them
-
limnus-basic-input
platform neutral input types
-
tiled-json-rs
parse and interact with Tiled editor JSON files
-
shura
A fast cross-plattform 2D component-based game framework
-
ra2-pal
Parser for Red Alert 2 palette files (*.pal)
-
dip
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
bevy_renet2
Bevy plugin for the renet2 crate
-
victorem
UPD Game Server Framework
-
bevy_consumable_event
add events to Bevy that can be consumed
-
yml_dialog
A very light base structure to implement an Rust Dialog using YML (file) format
-
re_math
An opinionated game math library built on top the excellent glam
-
gravitron
A GameEngine based on an ECS and Vulkan
-
wolfengine
Wolf is a set of modules for realtime rendering, realtime streaming and game developing
-
ezinput
A powerful input-agnostic library targeting complete support to axis and button handling for the Bevy game engine
-
bevy_gltf_export
Export bevy meshes into gltf scenes
-
salva3d
3-dimensional particle-based fluid dynamics in Rust
-
i_mesh
Mesh generation library
-
limnus-asset-registry
keeps track of asset lifetimes
-
rbp-nlhe
No-Limit Hold'em MCCFR solver with Pluribus-inspired abstraction
-
azalea-physics
Physics for Minecraft entities
-
space_shared
Subcrate for the space_editor crate. Contains the common types used in the space_editor
-
infrarust-api
Plugin API for Infrarust, a Minecraft reverse proxy
-
fyrox-texture
Texture utilities for Fyrox Engine
-
shipyard
Entity Component System
-
akioi-2048
A 2048 engine with multiplier tiles
-
ggez-goodies
Various small useful add-ons for the ggez game framework
-
catgirl-engine-client
Client side part of the catgirl-engine crate
-
bevy_sparse_tilemap
A Tilemap crate for the Bevy game engine with a focus on large map sizes and ECS sparse maps
-
bevy_cells
Bevy library for working with entities in grids
-
kudo
A minimalist Entity Component System. (Work in Progress)
-
limnus-window
Easily create and manage windows across multiple platforms for game applications, leveraging the power of the
winitlibrary -
usi-run
A command line utility for running games between USI compliant Shogi engines
-
infinitemedia-core
[WIP] An experimental timeline and sequence engine for orchestrating audio and visual events in Rust
-
bevy-blossom
A tiny Bevy plugin to add a bloom effect to cameras
-
bevy_cef_render_process
render process for bevy_cef
-
bevy_outline_post_process
An adaptive outline post-processing effect for the Bevy game engine
-
bevy_animations
2d Game Animation Engine built for Bevy
-
bevy_flair_style
Bevy UI styling using CSS
-
bevy_mod_paramap
Parallax mapping shaders (relief and POM) for the bevy game engine
-
emf-core-base-rs-ffi
Rust wrapper of the emf-core-base interface
-
bevy_flash
A Bevy plugin for Flash Animation
-
bz2-fastdl
Compresses source-engine game server files (maps, models, materials, etc.) using bzip2 for FastDL
-
action_maps
A dynamic action mapping system for Bevy
-
bhava
Emotion and personality engine — trait spectrums, mood vectors, archetypes, behavioral mapping
-
genesis
generating statically-typed ECS worlds
-
aerox_router
AeroX 路由和中间件系统
-
bones_schema
runtime reflection system designed for scripting
-
macroquad-ply
Temporary fork of macroquad with fixes for ply-engine. Do not depend on this directly.
-
ry-backend
Dual backend (raylib + SDL2) for game engines - Multiplatform with TTF, input, audio
-
bevy_osc
Send and receive OSC data to and from bevy and other programs or controllers
-
bevy_window
windowing functionality for Bevy Engine
-
dodgy_3d
ORCA, a local collision avoidance algorithm for 3D
-
bevy_split_canvas
A Bevy plugin to split the WASM canvas into multiple canvases
-
sdec-bevy
Bevy adapter for sdec schema + delta encoding
-
bevy_meshopt
Small wrapper around the
meshoptlibrary for using with Bevy! -
bevy_ecss
Allows using a subset of CSS to interact with Bevy ECS
-
reverie-engine-opengl
A toy game engine backed by OpenGL
-
ivy-templates
Provides
-
modde-games
Game plugin implementations for modde
-
ira_cli
Command line interface for preparing assets for Ira
-
uniasset
Unity ScriptableObject manipulation in Rust
-
bevy_ios_notifications
Bevy plugin to interact with iOS Notifications API
-
bevy_wasm_shared
Run WASM systems in Bevy
-
ltk_fantome
Helper library for working with League of Legends mods in the legacy Fantome format
-
bevy_axon_graphics
Bevy Axon Graphics
-
seldom_interop
Interoperability traits for Bevy components
-
bevy_doryen
A Bevy plugin that integrates the Doryen roguelike library with Bevy
-
quake_light_patterns
nodep library for the authentic quake lighting pattern animations
-
pybevy_sprite
Sprite components for PyBevy
-
godot-bevy-test
Integration testing framework for godot-bevy projects
-
bevy_tiled_camera
A camera for rendering low resolution pixel art in bevy
-
saft-sdf
Signed distance field function library
-
space_undo
Subcrate for the space_editor crate. Contains undo functionality.
-
bevy_aseprite_reader
Aseprite reader
-
game-grid
2D grid for prototyping games. Including easy parsing, indexing and iterators.
-
russimp-sys-ng
Raw Assimp bindings for Rust
-
bevy_tile_atlas
A TextureAtlas builder for ordered tilesets
-
bevy_transform
transform functionality for Bevy Engine
-
fennel-physics
Physics engine for the Fennel game engine
-
lightyear_sync
IO primitives for the lightyear networking library
-
bevy_activation
Entity activation manager for Bevy
-
raycoon
Minimal 2.5D raycasting engine
-
bevy_docs_extension_demo
testing rustdoc extensions for Bevy
-
smooth-bevy-cameras
Bevy camera controllers with buttery, exponential smoothing
-
bevy_enum_filter
Filter by enum variant in Bevy queries
-
bevy_talk
Voice chat while in game
-
ascending_camera
A basic camera solution for Rendering
-
fennel-common
Common package of Fennel game engine providing shared types
-
bevy_dogoap
-
aeronet_replicon
aeronetbackend implementation forbevy_replicon -
suon_movement
Entity movement and grid navigation for the Suon MMORPG framework
-
beet_router
ECS router and server utilities
-
chsl
2D Game Physics Engine supporting Joints/Constraints
-
shipyard_hierarchy
Hierarchy for Shipyard Entity Component System
-
moon-engine
A WebGL2/WASM Game Library written in the Rust programming language
-
overworld_incremental
Overworld Incremental Library - Tools for incremental games
-
morkovmap
A data-driven, Markov Chain-based tilemap generator library and app
-
bevy_mod_scripting_display
Traits focused on printing types with type information contained in the bevy type registry
-
bevy_log
logging for Bevy Engine
-
bevy_spectator
A spectator camera plugin for Bevy
-
myth_core
Core utilities and foundational types for the Myth engine
-
dotrix
3D Game Engine
-
gravita-collections
Pre-built game objects for rapid prototyping with Gravita
-
bevy_movement
Bevy plugin for easy move object to a destination
-
browser_input
Ergonomic input handling for WebAssembly applications in the browser with keyboard, mouse, and event processing
-
shogi_official_kifu
The official notation of shogi moves
-
rezcraft
Minecraft like game written in rust using wgpu, supporting both native and wasm
-
kifuwarabe_connect_four
WIP. Connect-four AI. Currently, does not work.
-
dmsdk
Rust-friendly wrappers around the Defold dmSDK
-
bevy_llm
bevy llm plugin (native + wasm)
-
dice_core
A robust library for parsing and rolling dice notation like '2d6+3'
-
rx_core_observable_connectable
connectable observable for rx_core
-
behavior-tree
behavior tree library for rust!
-
degen_toon_water
A toon water shader for bevy
-
chunksplitter-cli
CLI for splitting and merging Minecraft Bedrock Edition worlds for version control
-
obel_statechart
statechart plugin to implement complex game logics eg, behavior tree
-
tarmac
Resource compiler and asset manager for Roblox projects
-
mun_hir
high-level intermediate representation of Mun code
-
bevy_webview_wry
Allows you to create a webview based on wry
-
godot-rust-cli
easy way to use Rust with your Godot project
-
ambient_proxy
NAT traversal proxy for Ambient game engine
-
brefabs
Bevy Prefabs
-
russimp-sys
Raw Assimp bindings for Rust
-
q_screens
Screens extension for bevy
-
mmo
Libraries for building scalable game servers
-
cliw
Command Line In Web
-
cranium-test-plugin
extending the Cranium AI library with a Plugin for quickly setting up tests. Intended for first-party use.
-
mun_diagnostics
in-depth diagnostic information for compiler errors
-
dfhack-proto-srcs
Download and extract DFHack protobuf files from source
-
bevy_input_prompts
Mappings from bevy input types to popular input prompt asset paths
-
rouler
A container-like system for generating dice rolls
-
jackdaw
A 3D level editor built with Bevy
-
wow-alchemy-wmo
Parser, editor, and converter for World of Warcraft WMO (World Model Object) files
-
craballoc
Slab allocator with RAII
-
auburn
Fast and simple physics library
-
bevy-tnua-rapier3d
Rapier 3D integration for bevy-tnua
-
dreamwell-fabric
DreamFabric — presentation layer facade for Dreamwell. Orchestrates GPU pipeline (Quantum Culling, DreamMatter, meshlet rendering) for both runtime and editor.
-
arbor
A generic interface to the Monte Carlo Tree Search algorithm
-
our_economy_engine
Engine for the game Our Economy. Currently unusable, and progressing through rapid prototyping. Will often be half made, and be missing stuff.
-
alkyd
bevy crate for handling procedural textures and shaders
-
wow-alchemy-m2
Parser, validator, and converter for World of Warcraft M2 model files with animation support
-
sprite-gen
Procedurally generate pixel sprites library
-
bevy_device_lang
Crossplatform way to query device language setting
-
oxygengine-procedural
Procedural content generation module for Oxygengine
-
bevy_crossbeam_event
Fire Bevy events from crossbeam channels
-
aeronet_webtransport
WebTransport IO layer implementation for
aeronet -
elizaos-plugin-minecraft
Minecraft automation plugin for elizaOS (Mineflayer bridge client)
-
tm-rs
FFI bindings for the machinery api
-
unity-native-plugin-vulkan
Unity Native Plugin API (Vulkan) for Rust
-
bevy_basisu_loader_sys
A high level rust wrapper around the Basis Universal transcoder library
-
wow-alchemy-blp
Parser and encoder for World of Warcraft BLP texture files with DXT compression support
-
fts_gamemath
collection of crates that provide basic building blocks for 3d video game math
-
fmc_protocol
The fmc protocol
-
ciri
game engine using three-d
-
bevy_adventure
A framework for building adventure games in Bevy
-
logtra
A minimal logging library
-
retroboard
A chess retrograde move generator, suitable for endgame tablebase generation
-
bottomless-pit
A very simple 2D rendering/game engine inspired by raylib
-
bowtie
2D Game engine with messaging system
-
bevy-embasset
A Bevy plugin to embed assets in your game, or load assets from other sources!
-
pistoncore-glfw_window
A GLFW window back-end for the Piston game engine
-
rrise-headers
A helper for Rrise, generating headers based on soundbank definition files
-
bevy_tts
Text-to-speech for the Bevy game engine
-
bevy_gearbox_editor
State machine system for the bevy game engine
-
bevy_hanabi_loader
A wrapper around bevy_hanabi that lets you define your vfx files in RON format and load them into bevy
-
bevy_entity_graph
Create graphs of entities in the Bevy game engine
-
raywoke
Extremely simple raycasting crate
-
bevy_open_vat
OpenVAT (Vertex Animation Texture) plugin for Bevy
-
symbios-turtle-3d
Spatial interpretation layer for Symbios L-Systems using glam
-
bevy_mod_scripting_asset
Core traits and structures required for other parts of bevy_mod_scripting
-
limnus-log
Initializes logging
-
anput-physics
Physics plugin for Anput ECS
-
limnus-assets-loader
loads assets
-
landmass_rerecast
An integration to allow use of rerecast navigation meshes in landmass
-
sprite
Procedurally generate pixel sprites and save them in different formats
-
kengaai-audio
Audio system for KengaAI Engine with spatial audio support
-
bevy_schedules_ext
A Bevy plugin for expanding the use of schedules
-
main_game_loop
collection for building a winit game loop
-
bitshifter/bevy-physics-weekend
Game physics in one weekend with bevy
-
perovskite_core
Multiplayer voxel game written in Rust - Implementation details shared between client and server
-
renet2_setup
Setup utilities for renet2
-
bevy_mod_ffi_guest
FFI utilities for Bevy guests
-
souprune_mod_test
Test mod implementation for SoupRune SDK verification
-
chess_perft
package runs a 'perft' test on a particular chess position. This makes every move out to a certain depth, and counts the number of leaf-nodes. This is used to verify that move generation is correct and fast…
-
uuidmap
An ArrayHashMap implementation specialized for using a uuid (u128) as the key
-
bevy_map_runtime
Runtime map rendering via bevy_ecs_tilemap for bevy_map_editor
-
fyrox-animation
Flexible Animation System
-
bevy_ballistic
Bevy math functions to calculate projectile launch angles to hit a specific target
-
audir
Low-level audio library
-
vleue_navigator
Navmesh plugin for Bevy
-
ramirezmike/quien_es_el_mechaburro
A game made in one week for the Bevy engine's first game jam
-
wasm4fun-graphics
Graphics primitives and subsystems for WASM-4 fantasy console
-
bevy_auto_scaling
Auto scale cameras to fit the window
-
dacho
ECS Game Engine
-
bevy_button_released_plugin
Bevy helper crate that allows to react to button being released
-
blunders
UCI chess engine application
-
lib_tictactoe_menace
Tic Tac Toe game with a Menace AI
-
uci
programmatically communicate with UCI compatible chess engines
-
blenvy
Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side
-
rantz_random
Mostly just a wrapper around fastrand for a bunch of types. Supports bevy and rantz_spatial2d.
-
bevy_dirs
platform-specific data directories as asset sources in bevy
-
game_engine_core
The main loop of a game engine
-
voxquant_gltf
A program to convert triangle meshes to voxels
-
bevy_material_tool
A material replacement workflow for bevy
-
cuicui_layout
A layout algorithm for bevy and made to be understood by humans
-
planning
allowing the planning of minimal sequences of actions to achieve a goal state
-
rantz_cereal
A plugin for Bevy for handling saving and loading
-
bevy_bundlication
Replication rules for bevy_replicon based on a bundle pattern
-
html_to_bevy
A procedural macro to generate Bevy UI code from HTML-like syntax
-
bevy_serde_project
Stateful, structural and human-readable serialization crate for the bevy engine
-
stabilkon
Mesh builder for tile maps using using texture atlases
-
limnus-default-stages
limnus default stages,
First,PreUpdate,Update,PostUpdate, etc -
tcg_ai
Pokemon TCG game engine AI controllers
-
mcvm_shared
Shared libraries and utilities for mcvm crates
-
tawa_lili
Internal runtime library of musi_lili
-
cortenforge-sim-core
Bevy-based simulation runtime primitives (modes, config, plugins) for the CortenForge stack
-
geng-debug_overlay
Game ENGine
-
ayaka-primitive
Primitive types for Ayaka
-
bevy_yarnspinner
Bevy plugin for Yarn Spinner for Rust, friendly tool for writing game dialogue
-
bevy_shader_mtoon
Bevy MToon shader
-
bevy_gstreamer
GStreamer plugin for Bevy
-
maikklein/unreal-api
Rust integration for Unreal Engine 5
-
oxidized-codec
Minecraft protocol codec — VarInt/VarLong encoding, Packet trait, wire-format type readers/writers, frame encoding
-
bevy_2delight_anims
An fsm-driven 2d animation system that's _delight_ful to use
-
pybevy_math
Math types (Vec2, Vec3, Vec4, Quat, Mat3, Mat4) for PyBevy
-
vampirc-io
asynchronous, non-blocking, UCI protocol–based communication between chess UIs and chess engines
-
oxide-core-engine
Oxide Core engine - main game engine crate
-
tomb
A minimal crate that provides dice rolling mechanisms for games
-
pybevy_time
Time resources for PyBevy
-
bevy_ecs_rpc
Bevy ECS RPC serialization
-
chargrid_ggez
Graphical chargrid context which renders with ggez
-
retrofire-front
Frontends for writing simple programs with retrofire
-
bevy-toon
A tiny Bevy plugin for a toon shader
-
space_editor
Prefab editor for bevy game engine. Make levels/object templates with intuitive UI
-
spritesheet_detector
analyze spritesheets and detect sprite dimensions and frame count
-
bevy_hui_widgets
A collection of bevy components and systems to build widgets with
bevy_hui -
weirdboi_posthog
PostHog analytics integration for Bevy
-
notation_audio
Fun notation - audio features
-
macroquad-platformer
Platformer physics for macroquad
-
gdnative_tweener
A port of DoTween(3rd party package for Unity) to Godot 3.5, using GdNative
-
curseofrust-net-foundation
Bare networking layer on the top of unisock - for curseofrust
-
pecs_http
Asynchronous operations for Bevy Engine
-
candidate
fast chess move generator. It has a very good set of documentation, so you should take advantage of that. It (now) generates all lookup tables with a build.rs file, which means that…
-
sustenet
A networking solution for MMOs and large multiplayer games. It includes a master server, cluster servers, a client library, and authentication.
-
limnus-window-runner
winit runner for limnus-app
-
ambient_std
Ambient standard library extensions
-
bevy_vach_assets
Bevy Vach Assets is a plugin for Bevy Engine that allows you to load assets from Vach archives
-
bevy_mujoco
Use MuJoCo physics and MCJF / URDF scenes in bevy
-
bevy_kot_ui
UI utilities for bevy_kot
-
bevy_easy_compute
An easy way to run compute shaders for Bevy
-
zero_sum
An analysis engine for zero-sum games with game implementations
-
bevy_registry_export
Allows you to create a Json export of all your components/ registered types of your Bevy app/game
-
fennel-core
Core package of Fennel game engine providing rendering and audio
-
shady_shaders
An egui + wgpu toon/cel shader renderer for glTF and OBJ models
-
fyrox-build-tools
Build tools for Fyrox Engine
-
anvilkit-ecs
High-performance ECS module built on Bevy ECS for AnvilKit game engine
-
amethyst-editor-sync
Allows an Amethyst game to connect to an editor
-
bevy_camera_extras
containing a collection of utilities to making working with cameras in bevy easier
-
definitive
final vector & matrix library for Rust
-
bevy_heterogeneous_texture_atlas_loader
Load heterogenous texture atlases from a ron manifest
-
avian_rerecast
Avian backend for bevy_rerecast
-
cuicui_reflect_query
A bevy reflection addon to query world data from Reflect Components
-
naga-to-tokenstream
Creates a TokenStream describing parts of a Naga module
-
rbp-core
Core types, constants, and DTOs for robopoker
-
fmc
creating fmc servers
-
bevy_retrograde_ldtk
A Bevy Retrograde plugin for reading the LDtk 2D tile map format
-
bevy_hammer_ui
Barebones ui widget plugin built for Bevy
-
sge_ecs
ECS for SGE
-
bevy_fleet
bevy swarm diagnostic, event, metric, and telemetry client
-
kengaai-animation
Animation system for KengaAI Engine with skeletal animation support
-
specs-physics
nphysics integration for the Specs entity component system
-
limnus-gamepad-gilrs
Small wrapper around gilrs to provide gamepad abstraction
-
micro_bevy_web_utils
patching various missing parts from Bevy web/touch support
-
astrelis-text
Text rendering module for the Astrelis game engine
-
neos
NeosVR's API in rust
-
gtether
Highly concurrent multiplayer focused game engine, with an emphasis on realtime streamable asset management
-
rayngin
3D 6DF framework/engine for approach&click quests in rectangular chambers with objects consisting of balls
-
tehuti-socket
Socket engine for Tehuti communication system
-
chessbored
a chess board with movable pieces that behaves like a chessboard on the table
-
velis
View Expression Linked to Interactive State
-
ivy-input
Input handling crate for Ivy
-
oxidized-lighting
BFS light propagation engine — sky light, block light, cross-chunk boundary handling
-
devotee-backend-pixels
Pixels-based backend for devotee project
-
rx_core_scheduler_ticking
rx_core mock scheduler for tests and examples
-
naia-bevy-server
faciliate naia_server & Bevy interop
-
basis-universal-sys
Bindings for the basis-universal Supercompressed GPU Texture Codec by Binomial
-
pybevy_color
Color types (Color, LinearRgba, Srgba, Hsla, etc.) for PyBevy
-
treasury-store
Treasury storage
-
soulsand-world
Minecraft world management - chunk storage, block state sections, coordinate systems
-
bevy_headless_render
A plugin for the bevy engine which enables headless rendering to an image for use in the main world
-
rg3d-resource
Asset management crate for the rg3d engine
-
mooeye
A small UI library designed on top of the ggez game library. WORK IN PROGRESS
-
apecs-derive-canfetch
helper for writing apecs procedural macros
-
mevy_core_syntax
token handling for mevy_core!
-
pyrrhic-rs
A pure-Rust library to probe Syzygy Tablebases within a chess engine
-
rusty_gfx
Create windows, display graphics, handle input events (keyboard, mouse, etc.). Part of the rusty_engine game engine.
-
otter-support
Otter game system; support code Rust crate
-
lightyear_connection
Connection handling for the lightyear networking library
-
playdate-scoreboards
High-level Scoreboards API built on-top of Playdate API
-
physics-toy-sandbox
Remixable physics playground - Rube Goldberg machine builder for Jugar
-
bevy_connect
Connectivity via TCP sessions
-
bevy_libgdx_atlas
Support loading
libgdx.atlasfiles (used for sprite sheets and such) as Bevy assets -
jugar-web
WASM browser integration for Jugar game engine - Zero JavaScript computation
-
bevy_tiles
Bevy library for working with entities in grids
-
wasm4fun-sound
Sound primitives and subsystems for WASM-4 fantasy console
-
inexor-rgf-model-random
Inexor - Reactive Graph Flow - Model - Random
-
pretty_text
Core implementation for Bevy Pretty Text
-
check-buddy-pgn-parser
The PGN parser for check buddy
-
bevy_mod_ffi_host
FFI utilities for Bevy hosts
-
bevy_camera_shake
Adds camera shake to your cameras in Bevy Games
-
bevy-open-world
Various crates for open world rendering in Bevy
-
schachmatt
A chess library
-
lightyear_messages
IO primitives for the lightyear networking library
-
bevy_ecs_markers
🏷️ Markers for Bevy ECS Entities
-
mc_schem
read, create, modify and write various Minecraft schematic files
-
better_button
Extend Bevy buttons with on-entered and on-exited events for press, hover and mouse over states
-
bevy-tnua-rapier2d
Rapier 2D integration for bevy-tnua
-
burn_dragon_bevy
Bevy visualization for burn_dragon
-
chess-turn-engine
Chess turn engine library with all chess rules implemented. Can be used to implement a chess game.
-
berdicles
Expressive CPU particle system for the bevy engine
-
vulk-ext
Vulkan bindings for Rust, except only the bleeding edge features
-
daedalus
querying and parsing Minecraft metadata
-
rantz_camera2d
A 2D camera plugin for Bevy, inspired by the Love2D camera plugin - STALKER-X
-
bevy_observed_utility
Ergonomic and Correct Utility AI for Bevy Engine
-
aoaddons
creating addons for albion online game in multiple programing languages
-
ada
2D Primitive Shapes Rendering Library
-
kengaai-save
Save system for KengaAI Engine with save slot management
-
inexor-rgf-model-string
Inexor - Reactive Graph Flow - Model - String
-
bevy_fix_cursor_unlock_web
A tiny plugin that fixes Bevy not reporting when the cursor is unlocked on web
-
bevy_tasks
A task executor for Bevy Engine
-
gl-capture
Capture screenshot in OpenGL
-
bevy_compute_readback
Simplify compute shaders with readback in the Bevy game engine
-
modde-sources
Download source implementations for modde
-
bevy_flair_css_parser
Bevy UI styling using CSS
-
bevy-debug-camera
camera plugin perfect for debugging in 3D bevy games
-
kludgine-app
Application and Windowing for Kludgine
-
bevy_nokhwa
Nokhwa plugin for the bevy game engine
-
gilrs-core
Minimal event-based abstraction for working with gamepads
-
lib-vmm
Offical SDK for developing plugins for Void Mod Manager (VMM)
-
obel_reflect
provide rust reflect function to ease game developments
-
secs
Shit Entity Component System
-
bracket-random
Random number generator (xorshift based), focused on dice rolling. Optionally includes parsing of RPG-style dice strings (e.g. "3d6+12"). Part of the bracket-lib family.
-
cranium-actionset-loader
extending the Cranium AI library with asset-loaders from a variety of file formats
-
rpgx-dioxus
Dioxus plugin for the RPGX engine
-
shdrlib
High-level shader compilation and rendering library built on wgpu and naga
-
bevy_fabrik
IK solver for Bevy using FABRIK algorithm
-
bevy_retrograde_ui
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
scene-graph
a fast scene-graph for games and animation
-
gaclen
handling anything a game client needs to do
-
apparatus
A 2D game engine
-
maikklein/unreal-reflect
Rust integration for Unreal Engine 5
-
leafwing_abilities
A convenient, well-tested ability management suite. Built for the Bevy game engine.
-
gdrust
interacting with gdnative-rust a little easier
-
mtdf
A (bad) Rust implementation of the MTD(f) algorithm
-
bevy_rapier_collider_gen
generating bevy_rapier2d colliders, for bevy apps, from images with transparency
-
pgn_parser
PGN (Portable Game Notation) parser for chess games written in Rust. It allows you to parse PGN files and extract information about chess games.
-
tri_grid_render
Render helpers for tri_grid_sim simulation visualization
-
treasury-cli
Command Line Interface for treasury client
-
castagne-godot
Godot bindings for Castagne, the Fighting/Action game engine
-
bevy_tweening_captured
Tweening animation plugin for the Bevy game engine
-
libgnome-games-support-sys
FFI bindings for libgnome-games-support
-
async_shared
signal implementation
-
bevy_touch_camera
Touch camera for Bevy that supports drag and pinch to zoom
-
crankit-image
An ergonomic image API for the playdate
-
rafx-visibility
Rendering framework built on an extensible asset pipeline
-
anput-spatial
Spatial queries plugin for Anput ECS
-
bevy_animation_graph_editor
Animation graph editor for the Bevy game engine
-
lictl
A command line interface for scripting Lichess
-
aeronet_transport
Transport layer implementation for
aeronet -
rg3d-ui
Extendable UI library
-
rust_fish_chess_engine
A chess engine and functionality built in Rust. Built for the intention of incorporating it into my Svelte chess project through WASM.
-
devu_macro
A fast, minimal, and ergonomic entity-component-system library
-
shulkerscript-cli
Command line tool to compile Shulkerscript projects
-
godot-bindings
Internal crate used by godot-rust
-
sheep
Modular and lightweight spritesheet packing library
-
maikklein/unreal-movement
Rust integration for Unreal Engine 5
-
bevy_newtonian2d
2D Newtonian physics engine for Bevy
-
bevy_tileset_tiles
Tile definitions used by bevy_tileset
-
overworld_resource
Overworld Resource Library - Resource management
-
quaver-rs
parsing and analyzing Quaver rhythm game maps
-
bevy_serialization_physics
adding physics wrappers for bevy_serialization_extras
-
bevy_cef_debug_render_process
Debug render process for bevy_cef
-
bevy_blender_utils
Bevy companion plugin for bevy_blender_utils Blender addon
-
notation_bevy
Fun notation - bevy features
-
space_bevy_xpbd_plugin
Space XPBD plugin for space_editor crate
-
bevy_bulletml
BulletML library in Rust with Bevy game engine suppor
-
y-craft
Craft your dream 2D gaming experiences with the X-Craft engine
-
bones_utils
Utilites used throughout the bones_framework
-
newport_os
Os abstractions for engine use
-
luminol-data
Luminol's RPG Maker data structures
-
ivy-postprocessing
post processing helpers for ivy
-
ivy-random
random utility functions to the ivy framework
-
space_prefab
Subcrate for the space_editor crate. Contains the prefab systems and components.
-
dreamwell-runtime
Dreamwell Runtime — cross-platform GPU-accelerated game client
-
bevy_interact_2d
A Bevy plugin for 2d mouse interactions
-
oat
A chess engine
-
musi_lili
retro game engine for GB styled games written in Rust. Inspired by pico8.
-
castagne
Fighting/Action game engine core focusing on efficiency and flexibility. Made to be linked to another game engine like Godot.
-
geng-ecs
Game Engine (ecs)
-
dip_task
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
gdvariants
Rust std library collections wrapper that implements the godot-rust variant traits
-
bevy_quill_obsidian
An opinionated set of editor-focused widgets built on Bevy and Quill
-
cargo-geng
Game ENGine
-
spirit_edit_core
spirit editor
-
ready-paint
schema using wgpu and winit
-
vleue_kinetoscope
Animated GIF player for Bevy
-
geng-ui
Game ENGine
-
codegridfx
A grid-based visual scripting system for Eldiron
-
bevy-ui-gradients
Bevy UI gradients plugin
-
bevy_trickfilm
Bevy plugin for spritesheet manifest loading
-
bevy-wasm-tasks
integration of WASM tasks into a Bevy app for background processing
-
bevy_web_codecs
A plugin for Bevy that uses the WebCodecs API for decoding assets on the web
-
bevy_ui_forms
A bevy plugin for creating forms
-
obel_ast_map
Provides obel_ast_map
-
bevy_brp_extras
Extra BRP methods for Bevy apps including screenshot, shutdown, and keyboard input capabilities
-
bevy-fusabi
Bevy integration for the Fusabi scripting language
-
fyroxed_base
A scene editor for Fyrox game engine
-
rhachis
A game framework based off wgpu and winit
-
bevy_gizmos
gizmos for Bevy Engine
-
azalea-core
Miscellaneous things in Azalea
-
trenchbroom_steam_audio
Integration between bevy_steam_audio and bevy_trenchbroom
-
bevy_kot_ecs
ECS utilities for bevy_kot
-
jackdaw_remote
Remote game integration for the Jackdaw 3D level editor
-
cargo-pixel
2d pixel art game engine & rapid prototype tools support terminal,sdl2 and web
-
bevy_atomic_save
An atomic save/load system for Bevy Game Engine
-
bevy_confetti
Bevy confetti crate
-
bevy_rerecast
Bevy integration for rerecast
-
oxidized-transport
Minecraft protocol transport — Connection state machine, async reader/writer, framing pipeline
-
jugar-core
Core ECS, Game Loop, and State Management for Jugar game engine
-
bevy_replicon_renet2
Integration with renet2 for bevy_replicon
-
bevy_flurx_ipc
way for ipc communication using bevy_flurx
-
ellipsoid
2d cross-platform game engine
-
kengaai-ecs
Entity Component System for KengaAI Engine
-
rattle_items_match
Matching is not limited to character strings. I'm trying to make a game AI.
-
bevy_mod_scripting_lua
Necessary functionality for Lua support with bevy_mod_scripting
-
rs-tiled_json
A helper library to load JSON-formatted Tiled maps
-
retrofire-core
Core functionality of the retrofire project
-
ryot_pathfinder
specialized pathfinding functionalities for Bevy 2D, essential for dynamic navigation and movement within games
-
morkovmap_rc
A data-driven, Markov Chain-based tilemap generator library and app. Single-thread-flavored.
-
leafwing_manifest
A flexible crate for managing game assets that share a common structure. Manifests are generated from on-disk data, and offer a straightforward way to quickly look-up and generate game objects.
-
foxtrot
A 3D reference project and tech demo for the Bevy Engine
-
bracket-algorithm-traits
Traits required for the bracket-* crates. Adapt your maps to the traits with Algorithm2D, Algorithm3D and BaseMap.
-
entity_component
Entity and Component part of a full ECS
-
anvilkit-input
Keyboard, mouse, and gamepad input abstraction for AnvilKit game engine
-
godot-rust-cli-upgrader
A CLI tool to help you upgrade your Godot Rust CLI project between versions that introduce breaking changes
-
index_camera_passthrough
Camera passthrough for Valve Index on Linux
-
jackdaw_runtime
Runtime scene loader for the Jackdaw editor
-
bevy_mod_fbx
Autodesk Filmbox (*.fbx) loader for Bevy Engine
-
kill-them-all
A 'Path Of Exile' super lite 2D game
-
bones_render
Core rendering types for bones_lib
-
bevy_camera
camera abstraction for Bevy Engine
-
bevy-tnua-avian2d
Avian 2D integration for bevy-tnua
-
director
versatile, ergonomic state machine in Rust-lang
-
naia-bevy-shared
faciliate naia & Bevy interop, functionality shared by client & server versions
-
brass_engine
2D game engine with ECS, scripting and wgpu renderer
-
bevy_121
One-to-one relationships for Bevy ECS
-
rogalik_math
A basic math utils for the Rogalik engine
-
beet_examples
Bits and pieces for substantial beet examples
-
playdate-menu
High-level system menu API built on-top of Playdate API
-
catgirl-engine-common
Common crate for the catgirl-engine crate
-
rogalik
framework for 2d pixel games
-
limnus-scheduler-runner
Runs limnus schedulers
-
byml
Nintendo BYML (binary YAML) library in Rust
-
ivy-presets
Contains common presets for quickly setting up an application
-
bevier
An interactive CLI to generate Games using the Bevy Game Engine
-
bevy_config_cam
An easy plug-n-play multifunctional camera that allows for easy setup of a camera and player for a scene
-
bevy_wasm_sys
Import into your wasm scripts. Use with the bevy_wasm crate.
-
glacier-ini
Read and write Glacier Ini files
-
evoke
Powerful netcode for edict based game engines
-
pybevy_shader
Shader type wrappers for PyBevy (Shader, ShaderRef, ShaderImport, etc.)
-
anvilkit-audio
Cross-platform audio playback built on rodio for AnvilKit game engine
-
bevy_simple_scroll_view
plugin implementing ScrollView into Bevy engine
-
rafx-plugins
Rendering framework built on an extensible asset pipeline
-
wasm4fun-fmt
Formatting primitives for WASM-4 fantasy console
-
astrelis-assets
Asset management module for Astrelis game engine
-
renderling_forward
A forward shading WGPU rendering pipeline
-
bevy_dragon
Bevy visualization for burn_dragon
-
ambient_ecs
Ambient ECS. Host-only.
-
myopic-core
Core chess utilities
-
bevy_yarnspinner_example_dialogue_view
Example dialog view for Bevy Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
renderling_build
Helper for compiling GLSL shaders for renderlings. To be used in build.rs files.
-
rymder
Unofficial agones client SDK
-
pistoncore-sdl2_window
A SDL2 back-end for the Piston game engine
-
treasury-id
ID generator for treasury
-
renet2_steam
steam transport for the renet2 crate
-
mun_syntax
Parsing functionality for the Mun programming language
-
bevy_ios_safearea
Bevy plugin to query device safe area insets
-
hydrate-data
Game asset pipeline and authoring framework
-
bevy_poly_level
A 2d polygon-based level editor for bevy game engine
-
forky_bevy
Rust Utilities
-
storm
A personal 2D game engine designed for performance
-
rsbuf
A RuneScape update info computer
-
rg3d
3D Game engine
-
pico8-to-lua
Converts Pico-8's dialect of Lua to plain Lua
-
pybevy_shader_types
Shared ShaderMaterial types for PyBevy — no Python dependencies
-
rx_core_operator_catch
catch operator for rx_core
-
lightyear_avian2d
Helper library to use Lightyear with Avian2d
-
tanton
A blazingly-fast chess library
-
rx_core_subscriber_higher_order_concurrent
concurrent subscriber for rx_core
-
dodgy
ORCA, a local collision avoidance algorithm
-
oxidized-anvil
Anvil world format — RegionFile reader/writer, chunk serialization, level.dat
-
bevy-progressbar
Create multi sectons progressbars and use them in the bevy ui
-
bevy_mini_fps
Quick and dirty FPS display for bevy
-
bevy_jornet
Bevy plugin for Jornet - a social game server
-
kengaai-lod
Level of Detail (LOD) system for KengaAI Engine
-
chargrid_graphical
Graphical chargrid context
-
advancedresearch-nano_ecs
A bare-bones macro-based Entity-Component-System
-
lumifox_chess
A high-performance, no_std-capable chess engine library (bitboards and move generation)
-
wow-wmo
Parser, editor, and converter for World of Warcraft WMO (World Model Object) files
-
crankit-input
An ergonomic input API for the playdate
-
myth_resources
GPU resource definitions and data structures for the Myth engine
-
limnus-stage
Limnus stage that holds a vector of systems
-
san-rs
parsing standard algebraic notation (SAN)
-
avian_steam_audio
Integration between bevy_steam_audio and avian3d
-
mireforge-render-wgpu
render pixel perfect 2D sprites
-
board-game-traits
Traits for abstract game position representations
-
kayak_font
An SDF font renderer for Kayak UI and the Bevy game engine
-
obel_editor
core App functionality
-
bevy_nine_slice_ui
A nine slice/patch texture plugin for bevy ui nodes, works in wasm
-
yarnspinner_internal_shared
Shared internals for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
dreamwell-projects
Dreamwell project templates — starter kits for QTTPS applications
-
planck_ecs_bundle
Adds bundles to planck_ecs
-
bevy_regions
A region painting system using a u16 texture
-
sfn-tpn
saffron's two-player networking code for turn-based games
-
fyrox-material
Material and shader utilities for Fyrox Engine
-
geng-net
Game ENGine
-
bevy_aseprite
Bevy aseprite loader
-
bevy-agent
AI-powered Bevy game development assistant with GPT/Claude integration
-
bones_asset
Asset interface for bones_lib
-
anvilkit-camera
AnvilKit camera system - FPS, third-person, orbit, and free camera controllers with effects
-
recast-rs
Bindings for Recast from recastnavigation
-
bevy_retrograde_text
Bevy Retrograde's text rendering implementation
-
aerox_ecs
AeroX Bevy ECS 整合层
-
overworld_dice
Overworld Dice Library - Dice components
-
bevy_mod_scripting_script
script domain types for the BMS framework
-
silver_animation
A basic animation system for quicksilver
-
turbine_reactive
Design, Animate and Program Geometry
-
gdrust-trinkets
A collection of useful controls, traits, and macros for godot x rust development
-
chess-lib
A chess movement generator library
-
minecraft-assets
Parsing Minecraft asset files and resource packs in Rust
-
oxygengine-backend-web
Web backend module for Oxygengine
-
thebracket/rltk
A CP437/ASCII terminal library and helpers to make creating roguelike games in Rust easy. Similar to libtcod, but aiming to be Rust-native.
-
bevy_editor_pls_default_windows
In-App editor tools for bevy apps
-
kengaai-postprocess
Post-processing effects for KengaAI Engine
-
inexor-rgf-plugin-string
Inexor - Reactive Graph Flow - Plugin - String
-
steam-language-gen
Generate Rust bindings to Steam enums and messages
-
swamp-script-std
standard library for swamp
-
bevy_ios_impact
allows using ios ImpactFeedback API to generate haptic device vibrations
-
xdy
Complex RPG dice expression evaluator with histogram support
-
bevy_kill_my_cache
A plugin that kills your cache, but makes the Bevy scheduler go brrr
-
wormhole-engine
A portable, no-editor game engine with Rust core and Crystal scripting
-
ucui
A minimal UCI engine frontend experiment
-
luminol-ui
Luminol's UI code
-
mireforge-game-assets
Game asset loading
-
dashing
ASCII-style roguelike engine
-
bevy_moon
A world space UI for Bevy Engine
-
bevy_replicon_repair
Extends bevy_replicon with client-state repair for reconnects
-
bevy_video_glitch
A video glitch effect for bevy
-
spine2d-wgpu
wgpu renderer integration for the spine2d runtime
-
mcvm_net
Various network APIs for MCVM
-
inexor-rgf-plugin-numeric
Inexor - Reactive Graph Flow - Plugin - Numeric
-
bevy_slow_text_outline
Text outlines for the bevy game engine
-
bevy_mesh
mesh types for Bevy Engine
-
ayaka-script
First-class script language in Ayaka
-
game-networking-sockets-sys
Rust bindings for Valve GameNetworkingSockets library
-
pleco_engine
A blazingly-fast Chess AI
-
ladfile_builder
Language Agnostic Declaration (LAD) file format for the bevy_mod_scripting crate
-
limnus-scheduler
Limnus Scheduler trait
-
bevy_child_window
Allows you to create an embed child window in Bevy
-
swamp-script
script language for embedding
-
swamp-vm-instr-build
builds opcodes for the swamp vm
-
epicinium_server
An asynchronous multiplayer server for the strategy game Epicinium
-
bevy_proto_typetag
bevy_proto with typetag support
-
godot-ggrs-wrapper
GDNative project to provide GGRS to the Godot Engine
-
piston-float
Traits for generic floats in game development
-
uciengine
Use chess engine wrapper supporting uci command necessary for playing a game. Analysis is not supported.
-
wow-alchemy-cdbc
Parser for World of Warcraft DBC (client database) files with serialization support
-
spectra
Demoscene framework
-
wgsl-minifier
A command-line tool for minifying WGSL shaders
-
pybevy_input
Input components for PyBevy
-
bevy_sprite_animation
A Node Based Sprite Animatio Plugin, Bassed on Aarthificial's Reanimator
-
raylib-light
raylib bindings
-
gyges_engine
A powerful Gygès engine
-
beet-cli
Tools for building and deploying beet apps
-
bevy_rerecast_editor
Standalone editor for bevy_rerecast
-
anput-generator
Async generator library
-
ambient_math
Convenient mathematical operations for the Ambient runtime
-
bevy-basic-ui
A small manager for menus and huds
-
recastnavigation-sys
Raw FFI bindings for recastnavigation
-
wow-alchemy-data
Base data types used in parsing WoW binary formats
-
w-pgn
A pgn parser written in Rust
-
bevy_crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding (Bevy version)
-
mun_paths
convenience structures for handling relative- and absolute paths
-
playdate-lua
High-level Lua API built on-top of Playdate API
-
bevy_world_space_ui
Make building world space UIs easier in Bevy game engine
-
bevy_animation_graph_builtin_nodes
Animation graph library for the Bevy game engine
-
renderling_ui
User-friendly real-time 2d rendering. 🍖
-
ui4
A reactive vdom-free ui library for the bevy game engine
-
bevy_ecs_game
lightweight game framework built on Bevy ECS, focused on deterministic gameplay logic, AI systems, and scalable simulation. Designed for cross-platform projects and shared client/server architectures…
-
mun_compiler
Binary compilation functionality for Mun
-
oxygengine-visual-novel
Visual Novel module for Oxygengine
-
limnus
game engine core
-
mireforge-font
Font asset loading
-
bevy_webview
Rapidly iterate and build Bevy UI's with existing web-based technologies
-
bevy_input
input functionality for Bevy Engine
-
oxygengine-animation
Animation module for Oxygengine
-
mangrove-engine
2D game engine powered by swamp-script
-
bevy_ui_animation
A GSAP-like animation plugin for Bevy UI
-
bevy_wasm_scripting
Adds support for wasm/wat assets in Bevy, and enables easy scripting
-
hexga_wgpu
wgpu wrapped for hexga
-
lightyear_steam
Connection handling for the lightyear networking library
-
ugli
Game ENGine
-
bevy_plane_cut
A plane cut material for bevy
-
simbelmyne-chess
A chess library that takes care of board representation and move generation, used by the Simbelmyne chess engine
-
lightyear_webtransport
IO primitives for the lightyear networking library
-
bevy_mod_2d_hierarchy
Bevy plugin for more ergonomic 2d
-
bevy_prototype_networking_laminar
prototype of a networking crate for bevy. This create provides a low-level networking plugin built on top of laminar.
-
bevy_color
Types for representing and manipulating color values
-
oxidized-commands
Brigadier-compatible command framework — CommandDispatcher, parsing engine, tab completion
-
bevy_kot
Koe's Bevy toolkit
-
moonshine-check
Validation and recovery solution for Bevy
-
myth_scene
Hierarchical scene graph for the Myth engine
-
planck_game_features
Integrates game_features with the planck_ecs library
-
space_editor_ui
Subcrate for the space_editor crate. Contains the UI for the editor.
-
bevy_stat_bars
plugin for drawing floating stat bars
-
bevy_webview_core
webview's core logic for bevy_webview_projects
-
bevy_quicsilver
QUIC transport protocol for bevy_ecs, using quinn_proto
-
swamp-code-gen-program
converts a Swamp program to swamp-vm opcodes
-
shakmaty-uci
Universal Chess Interface (UCI) message parser
-
intuicio-framework-ecs
Entity-Component-System framework module for Intuicio scripting platform
-
crate_feature_graph
visualize the flow of features throughout your crate graph
-
godot-ffi
Internal crate used by godot-rust
-
bitstackchess
A bitboard‐based chess game engine with 10 × u128 move history
-
bevy_system_graph
creating strictly ordered execution graphs of systems for the Bevy game engine
-
bevy_map_codegen
Code generation for bevy_map_editor game projects
-
mireforge-material
image asset loading and material creation
-
beet_core
Core utilities and types for other beet crates
-
bevy_2d_inverse_kinematics
A 2D inverse kinematics plugin for Bevy
-
kengaai-particles
Particle system for KengaAI Engine
-
cuicui_chirp
A file format based on cuicui_dsl to describe bevy UIs
-
minigene
A minimalist terminal game engine
-
hydrate-loader
Game asset pipeline and authoring framework
-
obel_scene
scene to organize game objects
-
bevy_core_pipeline
core render pipeline for Bevy Engine
-
overworld_progression
Overworld Progression Library - Experience, Milestone and Level progression
-
dink-osrs
Old School Runescape Dink Plugin
-
cranium-core
Core code for a fast, modular, no_std-friendly, batteries-included library for Game AI written in Rust
-
hexe
A chess engine
-
pybevy_wgpu
wgpu type wrappers for PyBevy (matching bevy_image's wgpu-types dependency)
-
mortar_lsp
Mortar language LSP server
-
bevy_webp_anim
Plugin for loading and playing animated webp images in bevy
-
kengaai-navigation
Navigation mesh system for KengaAI Engine
-
bevy-simple-state-machine
A rudimentary animation state machine system for Bevy
-
nimble-participant
Nimble Participant
-
bevy_foliage_paint
A foliage painting system using warbler grass
-
bevy_kindly
Minimalistic implementation of entity kinds for Bevy ECS
-
bevy-codex
A manager for menus and huds with the bevy game engine
-
perft
Chess perft tools, for use with chess-oxide library
-
bevy_replicon_example_backend
transport intended only for examples
-
godot-codegen
Internal crate used by godot-rust
-
treasury-client
Client for treasury
-
oxidized-worldgen
World generation framework — ChunkGenerator, FlatWorldConfig, ChunkStatus pipeline
-
oxygengine-ha-renderer-debugger
Debugger for Hardware Accelerated renderer module for Oxygengine
-
oxidized-chat
Minecraft chat component system — Component tree, Style, ChatFormatting, TextColor, JSON/NBT serialization
-
fyrox-impl
Feature-rich, easy-to-use, 2D/3D game engine with a scene editor. Like Godot, but in Rust.
-
limnus-audio-device
Opens an audio output device
-
bevy_mod_scripting_bindings_domain
Definitions of shared interfaces from the bevy_mod_scripting_bindings crate
-
beet_rsx
An Astro inspired templating system built with bevy
-
rx_core_operator_materialize
materialize operator for rx_core
-
godot-core
Internal crate used by godot-rust
-
bevy_ios_app_delegate
Bevy Plugin to receive iOS AppDelegate callbacks
-
obel_diagnostic
diagnostic functionality
-
luminol-graphics
Luminol's graphics backend, used for rendering sprites and tilemaps
-
bevy_mod_scripting_rhai
Necessary functionality for Rhai support with bevy_mod_scripting
-
bevy_rerecast_editor_integration
Editor integration for bevy_rerecast_core
-
bevy-tnua-xpbd2d
XPBD 2D integration for bevy-tnua
-
ambient_gizmos
Ambient gizmos. Host-only.
-
poirebot-lichess
A chess bot for Lichess written in Rust
-
yarnspinner_codegen
Code generation for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
franim
A frame animation library for
no_stdgame-development -
pixelate_mesh
Apply a pixelation effect to any Bevy mesh or scene without post-processing
-
myth_assets
Asset loading and management for the Myth engine
-
mun_capi_utils
Common functionality between C api crates
-
bevy_state
Finite state machines for Bevy
-
piston-dyon_interactive
interactive coding with the Piston game engine
-
rafx-resources
Rendering framework built on an extensible asset pipeline
-
lightyear_avian3d
Helper library to use Lightyear with Avian3d
-
beet_utils
Base level utilities for beet crates
-
oxygengine-input-device-web
Web input devices module for Oxygengine
-
bevy_aoui
A light-weight anchor-offset based 2D sprite layout system for the bevy engine
-
godot-netpacket
building network packets for Godot
-
bevy_texture_atlas_tools
tools for working with Bevy Texture Atlases
-
bevy_file_asset
bevy file asset plugin
-
lightyear_utils
Utils shared by lightyear crates
-
lightyear_tests
Setup for integration tests for the lightyear networking library
-
gdnative-sys
Generated bindings to the Godot game engine's gdnative core types (See the gdnative crate)
-
piston-ai_behavior
AI behavior tree
-
lightyear_replication
IO primitives for the lightyear networking library
-
bones_scripting
Official scripting integration with bones_framework
-
mdbook_lad_preprocessor
Language Agnostic Declaration (LAD) file format for the bevy_mod_scripting crate
-
bevy_macro_utils
A collection of utils for Bevy Engine
-
bevy_picking
screen picking functionality for Bevy Engine
-
bevy_retrograde_audio
Bevy plugin for playing sounds
-
playdate-controls
High-level controls API built on-top of Playdate API
-
aeronet_channel
In-memory MPSC channel IO layer implementation for
aeronet -
pybevy_light
Light components for PyBevy
-
bevy-settings
struct as persistent settings between game launches. Usefull for e.g. storing the audio settings
-
bevy_mod_ui_texture_atlas_image
Draw images from texture atlases with the Bevy UI
-
lup
A custom indexed loop macro library for Rust
-
bevy_flurx_wry
mechanism to create a webview based on wry
-
alcibiades
A framework for writing chess engines in Rust
-
rx_core_operator_adsr
adsr operator for rx_core
-
limnus-wgpu-window
creating and managing a window with rendering surfaces using winit and wgpu
-
beet_design
Design system and components for beet rsx
-
hydrate-base
Game asset pipeline and authoring framework
-
geng-draw2d
Game ENGine
-
bevy_async_system
ability to wait for game status asynchronously
-
cuicui_dsl
An easily-extensible macro to spawn things in bevy
-
kengaai-ui
UI system for KengaAI Engine
-
bevy_gltf_animation
Minimal animation setup for gltf files
-
bevy_map
Complete 2D tilemap editor and runtime for Bevy games
-
bevy_retrograde_epaint
Epaint integration for rendering in Bevy Retrograde
-
pistoncore-event_loop
A Piston event loop for games and interactive applications
-
dip_desktop
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
lightyear_websocket
Websocket IO support for lightyear
-
bevy_animation_graph
Animation graph library for the Bevy game engine
-
sustenet-cluster
Sustenet's cluster module that connects to the master server and accepts client connections after being registered
-
bevy_simple_subsecond_system
Hotpatch your Bevy systems, allowing you to change their code while the app is running and directly seeing the results!
-
limnus-examples
examples for the limnus game engine
-
fyroxed
A standalone scene editor for Fyrox game engine
-
bevy-tnua-xpbd3d
XPBD 3D integration for bevy-tnua
-
fyrox-core
Shared core for the Fyrox engine and its external crates
-
pybevy_ui
UI components for PyBevy
-
pistoncore-input
A structure for user input
-
limnus-audio-stream
Audio low level stream
-
bevy_mod_stylebuilder
A set of fluent builder utilities for Bevy UI styles
-
pybevy_window
Window components for PyBevy
-
oxidized-compression
Minecraft protocol compression — Zlib compress/decompress, threshold management
-
mireforge-boot-game
Plugin to boot a mireforge-game
-
lightyear_prediction
IO primitives for the lightyear networking library
-
myth_animation
Animation system for the Myth engine (skeletal, morph target, property)
-
ambient_friendly_id
Streamlined replacement of
friendly_id -
oxidized-types
Shared foundational types (ChunkPos) for the Oxidized MC ecosystem
-
lightyear_raw_connection
Connection layer that directly uses the underlying IO
-
bevy_terminal_shader
An old school terminal shader for the bevy game engine
-
jackdaw_commands
Internal crate for the jackdaw editor
-
ambient_animation
Ambient animation functionality. Host-only.
-
piston-texture
A generic library for textures
-
luminol-filesystem
Luminol's virtual filesystem
-
oxygengine-overworld
RPG overworld module for Oxygengine
-
sustenet-client
Sustenet client used to connect to the master and cluster servers
-
rusty-editor
A scene editor for rg3d game engine
-
pybevy_mesh
Mesh components for PyBevy
-
pybevy_camera
Camera components for PyBevy
-
swamp-app
Application management for 2D pixel perfect sprite rendering
-
mun_memory
Memory management functionality for Mun
-
wgsl-inline
A macro used to embed WGSL within Rust
-
spew
helper for spawning objects in Bevy
-
bones_bevy_renderer
Bevy rendering implementation for the bones_framework
-
pybevy_pbr
PBR components for PyBevy
-
bevy_retrograde_physics
Physics utilities for Bevy Retrograde
-
oxidized-crypto
Minecraft protocol cryptography — AES-128-CFB8 stream cipher, RSA-1024 keypair generation, Minecraft SHA-1 digest
-
bevy_flair_core
Bevy UI styling using CSS
-
playdate-color
Color extension for Playdate API
-
rusty-chess-gui
A gui for the chess engine
-
bevy_despawn_with
Commands extension trait for despawning multiple entities
-
fps_counter
A Frames Per Second (FPS) counter
-
conditional_commands
Bevy Commands extension
-
beet_agent
ECS agentic workflow patterns
-
bevy_ui
A custom ECS-driven UI framework built specifically for Bevy Engine
-
beetmash_template
An example workflow for publishing Bevy apps and scenes to Beetmash
-
game_state_machine
A stack-based state machine with update functions
-
vleue_sentry
Sentry reporting plugin for Bevy
-
bevy_time
time functionality for Bevy Engine
-
rx_bevy_common
rx_bevy allocation context
-
bevy_cef_core
Core library for bevy_cef
-
specs_declaration
macro to effectively create SPECS systems
-
oxygengine-network
Network module for Oxygengine
-
oxygengine-audio-backend-web
Audio Web backend module for Oxygengine
-
dip_bundle
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
nimble-assent
Authoritative state
-
mun_runtime
A runtime for hot reloading and invoking Mun from Rust
-
bevy_ptr
working with untyped pointers in a more safe way
-
bevy_map_core
Core data structures for bevy_map_editor - Level, Layer, Tileset, Entity
-
lightyear_inputs_bei
Adds integration to network inputs from the bevy_enhanced_input crate for the lightyear networking library
-
godot-cell
Internal crate used by godot-rust
-
rx_core_operator_exhaust_map
exhaust_map operator for rx_core
-
fyrox-template-core
Project template generator for Fyrox engine
-
bevy_light
Keeps the lights on at Bevy Engine
-
ladfile
Language Agnostic Declaration (LAD) file format for the bevy_mod_scripting crate
-
bevy_hecs
Bevy fork of hecs: a fast, minimal, and ergonomic entity-component-system
-
mireforge-advanced-game
advanced game (logic, render, audio)
-
bones_bevy_utils
using Bones with Bevy
-
mireforge-boot-advanced-game
boot up an advanced game (logic, render, audio)
-
swamp-script-eval
interpreter for swamp script
-
ambient_input
Ambient input functionality. Host-only.
-
luminol-term
Luminol's in-built terminal
-
pybevy_animation
Animation types for PyBevy
-
jackdaw_jsn
Internal crate for the jackdaw editor
-
mun_project
convenience structures for Mun projects
-
oxidized-auth
Mojang authentication — GameProfile, session-server verification, profile properties
-
limnus-audio-sample
Load .wave files into asset
-
oxygengine-build-tools
Build tools for Oxygengine
-
swamp-script-analyzer
analyzer for swamp script
-
bevy_streamdeck
Elgato Stream Deck plugin for Bevy
-
pybevy_scene
Scene components and assets for PyBevy
-
pistoncore-window
window abstraction
-
beet_clanker
ECS agentic workflow patterns
-
limnus-default-keys
Default keys implementation for limnus
-
lightyear_frame_interpolation
IO primitives for the lightyear networking library
-
limnus-clock
clock management
-
flat_commands
bevy ecs extension traits
-
rx_core_operator_merge_map
merge_map operator for rx_core
-
lua_language_server_lad_backend
LADfile processor for the BMS scripting framework
-
mireforge-game
common mireforge game types
-
swamp-vm
Minimial virtual machine
-
oxidized-inventory
ItemStack, DataComponentPatch, MenuType, and item management utilities
-
yarnspinner_core
Core concepts for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
oxidized-physics
Minecraft physics engine — AABB collision detection, gravity, friction, voxel shapes
-
bevy_winit
A winit window and input backend for Bevy Engine
-
swamp-vm-host
host interface for the swamp VM
-
pybevy_transform
Transform component for PyBevy
-
oxygengine-navigation
Navigation module for Oxygengine
-
bevy_input_bms_bindings
Automatically generated bindings for bevy_input crate
-
leafwing_input_playback
Input recording and mocking functionality for the Bevy game engine
-
bevy_scene
scene functionality for Bevy Engine
-
bevy_shader
shader asset types and import resolution for Bevy
-
jackdaw_widgets
Internal crate for the jackdaw editor
-
lightyear_link
IO primitives for the lightyear networking library
-
beet_ecs
A very flexible AI behavior library for games and robotics
-
moonshine-core
Unconventional framework for making games in Bevy
-
mun_skeptic
ability to test Mun code snippets in an mdbook
-
rx_core_observable_combine_changes
combine_changes observable for rx_core
-
anput-jobs
Jobs plugin for Anput ECS
-
bones_framework
The Bones game development framework
-
rx_core_operator_concat_map
concat_map operator for rx_core
-
pybevy_text
Text types for PyBevy
-
mun_language_server
language server protocol server for the Mun language
-
limnus-asset-id
ownership asset ids
-
bevy_diagnostic
diagnostic functionality for Bevy Engine
-
bones_input
Core input types for bones_lib
-
pybevy_ecs
ECS components for PyBevy
-
mireforge-wgpu-sprites
wgpu sprite utility functions
-
oxygengine-editor-tools
Editor tools for Oxygengine
-
lightyear_metrics
Metrics recorder lightyear
-
bevy_mod_scripting_test_scenario_syntax
serde models for scenario syntax as used by the bevy_mod_scripting framework
-
bevy_rerecast_transmission
TODO
-
lightyear_inputs_native
IO primitives for the lightyear networking library
-
lightyear_udp
IO primitives for the lightyear networking library
-
jackdaw_geometry
Internal crate for the jackdaw editor
-
bevy_property
Dynamically interact with struct fields using their names
-
mun_vfs
in-memory filesystem
-
bevy_transform_bms_bindings
Automatically generated bindings for bevy_transform crate
-
swamp-wgpu-math
wgpu math types
-
bevy_type_registry
type registry for Bevy Engine
-
rx_core_operator_tap
tap next operator for rx_core, for the simple use cases where you don't want to define an entire observable to peek into one
-
anput-promise
Async promise library
-
piston3d-gfx_voxel
A voxel rendering library on top of Gfx
-
bevy_wgpu
A wgpu render backend for Bevy Engine
-
mun_libloader
Functionality for loading Mun libraries
-
jackdaw_camera
Internal crate for the jackdaw editor
-
pybevy_audio
Audio components and assets for PyBevy
-
bevy_gltf
Bevy Engine GLTF loading
-
lightyear_aeronet
IO primitives for the lightyear networking library
-
vngineer
Visual Novel game engine
-
bevy_sprite
sprite functionality for Bevy Engine
-
rx_core_observable_combine_latest
combine_latest observable for rx_core
-
lightyear_inputs
IO primitives for the lightyear networking library
-
beet_spatial
Spatial actions built upon beet_flow
-
bevy_gilrs
Gamepad system made using Gilrs for Bevy Engine
-
lightyear_inputs_leafwing
IO primitives for the lightyear networking library
-
swamp-app-examples
examples for swamp-render
-
bevy_utils
A collection of utils for Bevy Engine
-
bevy_ecs_bms_bindings
Automatically generated bindings for bevy_ecs crate
-
sustenet-master
Sustenet master server that accepts connections from cluster servers and clients. It also redirects clients to clusters.
-
rx_core_operator_map
map operator for rx_core
-
bevy_animation
animation functionality for Bevy Engine
-
oxygengine-integration-vn-ui
Integration module of visual novel and user interface for Oxygengine
-
swamp-runtime
runtime for swamp
-
oxygengine-input
Input module for Oxygengine
-
bones_ecs
flexible Entity Component System
-
oxygengine-integration-ui-ha
Integration module of user interface and Hardware Accelerated rendering for Oxygengine
-
bones_bevy_asset
Asset integration between bones_lib and Bevy
-
bevy_time_bms_bindings
Automatically generated bindings for bevy_time crate
-
beet_ml
Machine Learning actions built upon beet_flow
-
bevy_android
android functionality for Bevy Engine
-
oxygengine-physics-2d
2D physics module for Oxygengine
-
rx_bevy_observable_event
rx_bevy event observable, a glue between regular bevy events and observables
-
oxygengine-integration-ow-ha
Integration module of RPG overworld and Hardware Accelerated rendering for Oxygengine
-
bevy_rerecast_core
Core editorless Bevy integration for bevy_rerecast
-
bevy_api_gen
Code generator tool for bevy
-
piston-shaders
Shaders for game development in Rust
-
swamp-script-compile
Compile utility functions
-
bevy_input_focus
Keyboard focus management
-
pistoncore-event
flexible generic event threading
-
psyche-amethyst
Amethyst game engine integration for Psyche AI Toolset
-
mun_compiler_daemon
Functionality for continuously monitoring Mun source files for changes and triggering recompilation
-
bmf-parser
read BMFont binary files
-
swamp-boot-advanced-game
boot up an advanced game (logic, render, audio)
-
bevy_picking_bms_bindings
Automatically generated bindings for bevy_picking crate
-
bevy_ecs_macros
Bevy ECS Macros
-
rx_core_operator_delay
delay operator for rx_core
-
nimble-rust
Nimble
-
bevy_text
text functionality for Bevy Engine
-
rx_core_subject_async
async_subject for rx_core
-
lightyear_web
run a bevy app on the web
-
oxygengine-ignite-types
Ignite types module for Oxygengine
-
bevy_animation_bms_bindings
Automatically generated bindings for bevy_animation crate
-
swamp-wgpu-window
creating and managing a window with rendering surfaces using winit and wgpu
-
mun_lld
Bindings for LLD used to link Mun binaries
-
nimble-protocol
Nimble Protocol
-
oxygengine-script-web
Web scripting module for Oxygen Engine
-
nimble-seer
Nimble Prediction
-
bevy_remote
The Bevy Remote Protocol
-
rx_core_operator_subscribe_on
subscribe_on operator for rx_core
-
bevy_encase_derive
Bevy derive macro for encase
-
bevy_pbr_bms_bindings
Automatically generated bindings for bevy_pbr crate
-
bevy_ui_render
rendering functionality for Bevy UI
-
swamp-script-types
types used in Swamp
-
swamp-boot-game
Plugin to boot a swamp-game
-
oxygengine-script-flow
Visual graph scripting module for Oxygengine
-
oxygengine-ai
AI module for Oxygengine
-
swamp-game-assets
Game asset loading
-
limnus-system-runner
Runs limnus systems
-
bevy_anti_alias
various anti aliasing implementations for Bevy Engine
-
bevy_ninepatch
Displays 9-Patch UI elements in Bevy
-
bevy_light_bms_bindings
Automatically generated bindings for bevy_light crate
-
swamp-game-audio
Game audio