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