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