-
glam
fast 3D math library for games and graphics
-
bevy-inspector-egui
Inspector plugin for the bevy game engine
-
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
-
bevy_mod_picking
A modular picking plugin for Bevy
-
bvh
A fast BVH using SAH
-
raylib
Safe Rust bindings for Raylib
-
bevy_ecs
Bevy Engine's entity component system
-
leafwing-input-manager
A powerful, flexible and ergonomic way to manage action-input keybindings for the Bevy game engine
-
bevy_tweening
Tweening animation plugin for the Bevy game engine
-
bevy_asset_loader
Bevy plugin for asset loading
-
gilrs
Game Input Library for Rust
-
tiled
loading maps created by the Tiled editor
-
bevy_ecs_tilemap
A tilemap rendering plugin for bevy which is more ECS friendly by having an entity per tile
-
alchemyst
PCG tool based on Intuicio scripting platform
-
bevy_prototype_lyon
Draw 2D shapes and paths in the Bevy game engine
-
jomini
Low level, performance oriented parser for save and game files from EU4, CK3, HOI4, Vic3, Imperator, and other PDS titles
-
bevy_replicon
High level networking for the Bevy game engine
-
shakmaty
Chess and chess variant rules and operations
-
bevy_panorbit_camera
A basic pan and orbit camera in Bevy
-
avian2d
An ECS-driven physics engine for the Bevy game engine
-
bevy_rapier2d
2-dimensional physics engine in Rust, official Bevy plugin
-
sfml
Rust binding for sfml
-
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.
-
cc7800
a subset of C compiler for Atari 7800
-
bevy_easings
Easing plugin for Bevy
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
bevy_hanabi
Hanabi GPU particle system for the Bevy game engine
-
bevy_flowfield_tiles_plugin
FlowField (vector field) pathfinding as a plugin to the Bevy game engine
-
hexx
Hexagonal utilities
-
bevy_flycam
Basic first-person fly camera for the Bevy game engine
-
big-brain
AI library
-
flecs_ecs
Rust API for the C/CPP flecs ECS library https://github.com/SanderMertens/flecs
-
shipyard
Entity Component System
-
bevy_kira_audio
Bevy plugin for dynamic audio
-
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…
-
mc-repack
A command-line interface for repacking Minecraft mods and resource packs to optimize size and loading speed
-
steamworks
friendly bindings to the steamworks sdk
-
voxelize
A fast multiplayer voxel engine
-
bevy_infinite_grid
A 3D infinite grid for Bevy
-
virtual_joystick
Bevy virtual Joystick for mobile games
-
bevy-persistent
A Bevy helper to easily manage resources that need to persist across game sessions
-
roboat
A high performance interface for the Roblox API
-
micro_ldtk
Load data from LDTK, index it and make it accessible through Bevy assets, extract and use autotile rules
-
game-loop
that implements a frame-rate-independent game loop
-
bevy_voxel_world
A voxel world plugin for Bevy
-
dolly
Composable camera rigs
-
dora-ssr
The lib for building Dora SSR game as wasm32-wasi that runs on multi-platform Dora SSR engine
-
moonshine-save
Save/Load framework for Bevy
-
bevy_mod_raycast
Ray Casting for the Bevy Engine
-
bevy_pancam
A camera that allows panning by dragging with the mouse
-
bevy_rand
A plugin to integrate rand for ECS optimised RNG for the Bevy game engine
-
bevy_spritesheet_animation
A Bevy plugin for animating sprites
-
chuot
AGPL licensed and opinionated game engine for pixel-art games
-
piston
game engine core libraries
-
seldom_state
Component-based state machine plugin for Bevy. Useful for AI, player state, and other entities that occupy various states.
-
bevy_mod_scripting
Multi language scripting in Bevy
-
bevy_mod_physx
PhysX plugin for Bevy
-
ggez
A lightweight game framework for making 2D games with minimum friction, inspired by Love2D
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
bevy-tnua
A floating character controller for Bevy
-
hill_vacuum
A bevy-based 2D map editor
-
ndm
Parse standard polyhedral dice notation
-
bevy_particle_systems
A particle system plugin for Bevy
-
ludusavi
Game save backup tool
-
bevy_dolly
The dolly abstraction layer for the bevy game framework
-
bevy_gltf_blueprints
Adds the ability to define Blueprints/Prefabs for Bevy inside gltf files and spawn them in Bevy
-
micro_banimate
Easily manage complex Bevy 2D sprite animations
-
bevy_mod_debugdump
Visualization tools for bevy
-
avian3d
An ECS-driven physics engine for the Bevy game engine
-
bevy_debug_grid
A bevy plugin for creating grids, for debugging purposes
-
iyes_perf_ui
Customizable Performance/Debug Overlay for Bevy UI
-
allegro_examples
Allegro 5 wrapper examples
-
node_tree
An extendable scene graph made up of autonomous execution services known as nodes organized in a tree of processes. Inspired by Godot!
-
bevy_atmosphere
A procedural sky plugin for bevy
-
bevy_ecs_tiled
A Bevy plugin for loading Tiled maps
-
catgirl-engine
A game engine for cool moddability and procedurally generated data
-
rollo
A Rust-based multiplayer framework
-
chessie
Fast chess library, suitable for use in chess engines
-
edict
Powerful entity-component-system library
-
devotee
Visualization engine
-
scryfall
A wrapper around the scryfall magic the gathering api
-
bevy_scriptum
Plugin for Bevy engine that allows you to write some of your game logic in a scripting language
-
bevy_defer
asynchronous runtime for executing async coroutines
-
bevy_fast_tilemap
A GPU accelerated tilemap for bevy
-
pixels-graphics-lib
pixel graphics and GUI library
-
bevy-sequential-actions
A Bevy library for executing various actions in a sequence
-
godot
Rust bindings for Godot 4
-
ghx_proc_gen
2D & 3D procedural generation with WFC/Model synthesis
-
bevy_mod_billboard
Billboard text and texture support for bevy
-
bevy_third_person_camera
A third person camera written for Bevy
-
apecs
An asyncronous and parallel entity-component system
-
yarnspinner
The friendly tool for writing game dialogue
-
simpleton
runner for Intuicio scripting platform
-
good-web-game
An alternative implementation of the ggez game engine, based on miniquad
-
rusty_engine
Learn Rust with a simple, cross-platform, 2D game engine
-
vrc
Unofficial rust types of VRChat's API
-
bevy_rapier3d
3-dimensional physics engine in Rust, official Bevy plugin
-
three-d-asset
Load/save functionality for 3d applications
-
bevy_magic_light_2d
Experimental dynamic 2D global illumination system for Bevy, based on SDF ray-marching and screen space irradiance cache probes
-
spew
helper for spawning objects in Bevy
-
bevy_bsml
A UI library to compose UI elements using simple markup language, inspired by svelte and tailwindcss
-
bevy-tokio-tasks
integration of a Tokio runtime into a Bevy app for background processing
-
flax
An ergonomic archetypical ECS
-
bevy_screen_diagnostics
Bevy plugin for displaying diagnostics on screen
-
bevy_slinet
networking plugin for bevy
-
bevy_slippy_tiles
slippy tile fetching functionality in the Bevy game engine
-
pix-engine
A cross-platform graphics/UI engine framework for simple games, visualizations, and graphics demos
-
cardpack
Generic Deck of Cards
-
bevy_trackball
Coherent virtual trackball controller/camera plugin for Bevy
-
bevy-ui-navigation
A bevy plugin to make implementing ui navigation in your game a piece of cake
-
bevy_simplenet
server/client channel implemented over websockets with support for Bevy
-
sparsey
Entity Component System based on sparse sets
-
lightyear
Server-client networking library for the Bevy game engine
-
bevy_stardust
A networking crate for the Bevy game engine
-
gba
‘raw’ style GBA development. If you want a ‘managed’ experience, try the
agbcrate instead. -
bladeink
port of inkle's ink, a scripting language for writing interactive narrative
-
oxidized_navigation
A Nav-Mesh generation plugin for Bevy Engine
-
transvoxel
Eric Lengyel's Transvoxel Algorithm
-
bevy_smud
2d sdf shape renderer plugin for Bevy
-
bevy_svg
Load and draw SVG files in Bevy
-
warbler_grass
A bevy plugin for creating 3d grass in your game
-
basis-universal
Bindings for the basis-universal Supercompressed GPU Texture Codec by Binomial
-
bevy_collider_gen
generating colliders, for bevy apps, from images with transparency
-
tegra_swizzle
Tegra X1 block linear texture memory tiling
-
bevy_silk
Cloth physics implementation in bevy
-
bevy_trenchbroom
Bevy integration with TrenchBroom
-
flecs
Rust bindings for the Flecs Entity Component System
-
rapier_testbed3d
Testbed for the Rapier 3-dimensional physics engine in Rust
-
smooth-bevy-cameras
Bevy camera controllers with buttery, exponential smoothing
-
swamp-examples
Examples for the swamp 2D game engine
-
bevy_cosmic_edit
Bevy cosmic-text multiline text input
-
pagurus
Ultra-portable game engine suited for offline 2D games powered by WebAssembly
-
keyframe
animation in Rust
-
dark_iron_ecs
Entity Component System library for Rust
-
magpie
Reasonably efficient Othello library built with bitboards
-
mun_hir
high-level intermediate representation of Mun code
-
bevy_mod_index
Allows using indexes to efficiently query for components by their values in the game engine Bevy
-
bevy_client_server_events
Simplified game networking
-
bevy_sprite3d
Bevy Plugin to allow using 2d sprites in a 3d scene
-
bevy_basic_portals
A portal plugin for Bevy game engine
-
rbx_types
Types used to represent Roblox values
-
bevy_ggrs
Bevy plugin for the GGRS P2P rollback networking library
-
geese
Dead-simple game event system for Rust
-
bevy_simple_tilemap
Refreshingly simple tilemap implementation for Bevy Engine
-
bevy_obj
Wavefront OBJ mesh asset loader plugin for the Bevy engine
-
bevy-ui-dsl
A DSL library that simplifies the creation of widgets for bevy_ui
-
bevy_mod_outline
A mesh outlining plugin for Bevy
-
egui-wgpu
Bindings for using egui natively using the wgpu library
-
gdman
A CLI application for managing versions of Godot
-
simdnoise
SIMD accelerate noise library with runtime feature detection
-
bevy_vox_scene
A Bevy engine plugin for loading Magica Voxel world files and render materials directly in Bevy as a scene graph
-
coup
game implemented in the CLI
-
bevy_vello
Render assets and scenes in Bevy with Vello
-
bulls-and-cows
A framework for building bulls-and-cows games (1A2B) for any data type
-
aery
Non-fragmenting ZST relations for Bevy
-
luminol
FOSS recreation of RPG Maker XP in Rust with love ❤️
-
dbsdk-cli
Command-line utility to simplify building Rust games for the DreamBox fantasy console
-
bevy_audio_controller
Bevy plugin for managed audio playback
-
bevy_light_2d
General purpose 2d lighting for the Bevy game engine
-
rpfm_extensions
contains extended functionality (dependencies manager, global search,…) over the
rpfm_libcrate, meaning stuff that didn’t fit in there, it’s here -
shroud
Universal library for discovering rendering functions of render engines: DirectX9, DirectX10, DirectX11, DirectX12
-
symbolic-unreal
Parsing and processing utilities for Unreal Engine 4 crash files
-
bevy_landmass
A plugin for Bevy to handle navigation of AI characters
-
impacted
2d collision test for arbitrary convex shapes
-
luau0-src
Minimal sources of Roblox Luau and logic to build them
-
repath
A fast pathfinding library using A* algorithm, caching, precomputation and path segmentation with concurrent pathfinding
-
seldom_pixel
Bevy plugin for limited color palette pixel art games
-
bevy_tween
Flexible tweening plugin library for Bevy
-
rsmod-pathfinder
A breadth-first search path finder
-
bevy_lazy_signals
An ad hoc, informally-specified, bug-ridden, kinda fast implementation of 1/3 of MIT-Scheme
-
bevy-steamworks
A Bevy plugin for integrating with the Steamworks SDK
-
pyxel-engine
Core engine for Pyxel, a retro game engine for Python
-
kludgine
A wgpu-powered 2d graphics library with optional windowing support
-
iyes_progress
Bevy plugin to help implement loading states
-
bevy_stl
STL loader for bevy, based on stl_io
-
bevy_console
dev console for bevy
-
gyges
board game Gygès
-
line_drawing
A collection of line-drawing algorithms for use in graphics and video games
-
laminar
semi-reliable UDP protocol for multiplayer games
-
bevy_despawn_particles
An event-based plugin for Bevy to spawn particles on despawn that are built from the original texture
-
haalka
ergonomic reactive Bevy UI library powered by FRP signals
-
sdl2-sys
Raw SDL2 bindings for Rust, used internally rust-sdl2
-
bevy_ecs_ldtk
An ECS-friendly ldtk plugin for bevy
-
pixel_loop
A pixel based drawing engine based on the idea of a self stabilizing update loop
-
smol-rgb
A smol library for (s)Rgb color handling
-
bevy_material_tool
A material replacement workflow for bevy
-
rantz_spatial2d
A set of 2D spatial utilities for Bevy, including handling transform propagation
-
hive-engine
A game engine for Hive
-
bevy-parallax
A Bevy plugin for creating a parallax effect
-
bevy-trait-query-0-14-0
trait queries for the bevy game engine
-
unity-native-plugin
Unity Native Plugin API for Rust
-
oktree
Fast octree implementation to handle voxel-like data in Bevy game engine
-
gamie
abstractions for several classic tiny games
-
spire_tween
A Slimy tweener library for Godot(4.2+), inspired on the design of DoTween(3rd party package for Unity)
-
cc2600
a subset of C compiler for Atari 2600
-
bevy_ldtk_asset
A Bevy plugin to support LDtk files as assets!
-
legion
High performance entity component system (ECS) library
-
brood
A fast and flexible entity component system library
-
bevy_framepace
Frame pacing and frame limiting for Bevy
-
extol_sprite_layer
Explicitly-defined sprite layers for Bevy, including automatic y-sorting
-
emergent
Toolset for producing emergent gameplay for games written in Rust
-
tatami-dungeon
A roguelike dungeon generation algorithm
-
bevy_common_assets
Bevy plugin adding support for loading your own asset types from common file formats such as json and yaml
-
agones
SDK for Agones
-
bevy_mod_reqwest
Bevy http client using reqwest, with a focus on simple usage within the bevy runtime
-
uesave
Unreal Engine save file (GVAS) reading/writing
-
chess-oxide
A chess engine library written in Rust, with a GUI bin to play against it
-
bevy-trait-query
trait queries for the bevy game engine
-
ratwenture
atventure clone
-
aoe2-probe
editing aoe2scenario files from AoE2 DE
-
macaw
An opinionated game math library built on top the excellent glam
-
curvo
NURBS modeling library
-
godot-binary-serialization
A Godot binary serializer to encode & decode types from & to godot
-
bevy_state_curves
A state saving and management crate for the Bevy Game Engine saving via curve keyframes
-
bevy_vector_shapes
rendering vector shapes using the Bevy game engine
-
wgsl-tools
Various tools to parse, verify, evaluate and modify wgsl shader source
-
bevy_hui
pseudo Html templating ui crate for the bevy-engine
-
bevy_logic
A logic gate simulation plugin for Bevy
-
bevy_polyline
Polyline Rendering for Bevy
-
meshtext
Generate vertex-vertex meshes from text
-
zero_ecs
Entity Component System (ECS), using only zero-cost abstractions
-
twee-tools
A compiler for Twine stories
-
saunter
tick based game engines
-
bevy_doryen
A Bevy plugin that integrates the Doryen roguelike library with Bevy
-
brawllib_rs
Brawl character file parser, based on brawlbox/brawllib
-
revy
Proof-of-concept time-travel debugger for Bevy, built with Rerun
-
chilloutvr
Unofficial rust types of ChilloutVR's API
-
bevy_procedural_meshes
Procedural Meshes for the Bevy game engine
-
bevy_easy_localize
Lightweight localization in bevy
-
regecs
Rust Extended Generic ECS (REGECS)
-
ambient_element
Element is a React-inspired virtual tree library for the Ambient runtime
-
lavagna
The uncluttered blackboard
-
gorrosion
Go/weiqi/igo/baduk/goe whatchamacallit
-
bevy_quinnet
Bevy plugin for Client/Server multiplayer games using QUIC
-
vbsp
Rust parser for valve bsp files
-
cala
Make portable apps and video games in Rust!
-
bevy_turborand
A plugin to enable ECS optimised random number generation for the Bevy game engine
-
blue_engine
General-Purpose, Easy-to-use, Fast, and Portable graphics engine
-
bevy_ios_iap
Bevy Plugin and Swift Package to provide access to iOS native StoreKit2 from inside Bevy Apps
-
caith
A dice roller library supporting many features
-
bevy_health_bar3d
Health bar for bevy implemented as a billboard shader
-
break-eternity
A numerical library to represent numbers as large as 10^^1e308 and as 'small' as 10^-(10^^1e308)
-
vpin
virtual pinball ecosystem
-
bevy_impulse
Reactive programming and workflow execution for bevy
-
emerald
A lite, fully featured 2D game engine
-
rpkg-rs
Parse Glacier ResourcePackage (rpkg) files, allowing access to the resources stored within
-
bevy_fps_controller
Bevy plugin that adds a Source engine inspired FPS movement controller
-
bevy_editor_pls
In-App editor tools for bevy apps
-
bevy_entitiles
A 2d tilemap library for bevy. With many useful algorithms/tools built in.
-
hecs-hierarchy
Hierachy implementation for Hecs ECS
-
dexterous_developer
A modular hot reload system for rust
-
bevy_macro_utils
A collection of utils for Bevy Engine
-
nightrunner_lib
A parser library for making text adventure games
-
witer
An iterator-based Win32 windowing library
-
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…
-
ldtk_rust
LDtk 2D level editor to build games in Rust
-
playdate
High-level Playdate API
-
riichi_hand
A collection of utilities for working with Riichi Mahjong player hands
-
transform-gizmo-bevy
bevy integration for transform-gizmo
-
hapi-rs
Rust bindings to Houdini Engine API
-
bevy-settings
struct as persistent settings between game launches. Usefull for e.g. storing the audio settings
-
casino_poker
that provides hand ranking & the backend for poker games
-
bevy_log_events
A Bevy plugin that log events
-
bevy-input-sequence
Recognizes input sequences and send events
-
bevy_life
Generic and dynamic cellular automaton lib for bevy
-
ascii-forge
A Minimal TUI Ascii Application Engine that simplifies the use of crossterm
-
bevy_lit
A lighting 2d library for Bevy
-
bevy_enoki
2D Particle system plugin, that works well in wasm
-
bevy_fluent
Bevy plugin for localization using Fluent
-
cecs
Entity database for the game 'Cao-Lo'
-
bevy_compute_noise
A Bevy plugin for generating tilable 2D/3D noise textures using compute shaders
-
rust_flightplan
Loads a flight plan from SimBrief and decodes it
-
benimator
A sprite animation library for rust game development
-
fyrox
Feature-rich, easy-to-use, 2D/3D game engine with a scene editor. Like Godot, but in Rust.
-
deterministic-trigonometry
Trigonometry without floating point variables to achieve deterministic results across hardware and compilers
-
bevy_mod_xr
semi generic Xr Api for Community Driven XR in Bevy
-
wgsl_preprocessor
An unofficial preprocessor for WGSL written in Rust for WGPU
-
shrev
Event channel, meant to be used with
specs -
bevy_mod_async
Ergonomic async tasks plugin for the Bevy game engine
-
classicube-sys
Rust C bindings for ClassiCube
-
bevy_flurx
Allows you to write sequential description of processes involving delays, user input, and other waits
-
vleue_navigator
Navmesh plugin for Bevy
-
goldsrc-rs
Collection of file's parsers for goldsrc engine
-
cao-lang
The back-end of cao-lang, a node based visual scripting language
-
gdnative
The Godot game engine's gdnative bindings
-
bevy_text_mode
Bevy plugin adding a texture atlas sprite with configurable background and foreground colors
-
agb_hashmap
no_std hashmap implementation intended for use in the
agblibrary -
bevy_sync
Plugin for synchronizing entities and components between server and its clients
-
bevy-async-ecs
Asynchronous interface for Bevy ECS
-
forky
Rust Utilities
-
renom
program to rename Unreal Engine projects
-
bevy-debug-text-overlay
A convenient on-screen message print macro for bevy
-
pure_rng
rand-compatible RNG library for generating repeatable, controlled random values, designed primarily for use in games
-
bevy_firework
CPU-driven, batch-rendered particle system for the Bevy game engine
-
bevy_guessture
Bevy plugin wrapping the
guessturecrate’s gesture recognition API -
bracket-lib
Meta-crate holding the entirety of bracket-lib (and exposing it). Use this for the full roguelike toolkit experience.
-
crossbow
Cross-Platform build tools and toolkit for games
-
mod_plugins
Reduce plugin boilerplate in the Bevy game engine
-
mtnrust
start for rust publish done by Metin Ilhan, will be improved later
-
ABC-ECS
fast, and flexible Entity-Component-System library for Rust
-
bevy_spine
Spine plugin for Bevy utilizing rusty_spine
-
moonshine-behavior
Minimalistic state machine for Bevy game engine
-
pixelate_mesh
Apply a pixelation effect to any Bevy mesh or scene without post-processing
-
bevy-earcutr
earcutr + Bevy
-
bevy_ineffable
A simple-to-use input manager for bevy that empowers players and makes accessibility easy
-
bevy_button_released_plugin
Bevy helper crate that allows to react to button being released
-
egui_ratatui
WASM ratatui with egui works with bevy and macroquad and eframe
-
rust_pixel
2d pixel art game engine & rapid prototype tools support terminal, sdl2, and web
-
ozz-animation-rs
runtime library for ozz-animation with cross-platform deterministic
-
bevy_keith
2D graphics library for the Bevy game engine
-
rlifesrc
A Game of Life pattern searcher
-
bevy_magic_fx
Define mesh-based vfx in serialized files
-
bevy_modern_pixel_camera
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
sprite_dicing
Cross-engine tool for lossless compression of sprite textures with identical areas
-
bevy_args
bevy plugin to parse command line arguments and URL query parameters
-
bevy_async_task
Ergonomic abstractions to async programming in Bevy
-
bevy_state
Finite state machines for Bevy
-
bevy_ratatui_render
A bevy plugin for rendering your bevy app to the terminal using ratatui
-
ambient_proxy
NAT traversal proxy for Ambient game engine
-
ba2
working with the Bethesda archive file format
-
hecs-schedule
shedulable systems and parallel execution for hecs
-
bevy_web_keepalive
Bevy plugins to keep a bevy app running in the browser despite not being visible
-
blenvy
Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side
-
bhv
providing means to create and use Behavior Trees
-
joycon-rs
a framework for dealing with Nintendo Switch Joy-Con on Rust easily and efficiently
-
bevy_mod_imgui
A Dear ImGui integration for the Bevy game engine
-
cvars
Configuration variables - a simple and ergonomic way to store and edit configuration at runtime
-
macroquad-canvas-2d
Add canvas functionality to macroquad
-
rpg-stat
computer stats for RPG game development
-
bevy_mod_speedup
collection of ways to increase the performance of your application
-
oml-audio
Very basic, and thin abstraction of audio handling meant for games
-
bevy_synthizer
A Bevy plugin for Synthizer, a library for 3D audio and synthesis with a focus on games and VR applications
-
geng
Game ENGine
-
oxygengine-backend-web
Web backend module for Oxygengine
-
buttery
smooth transformations with a nice API
-
bevy-histrion-packer
A Bevy plugin to allows to efficiently pack all game assets, such as textures, audio files, and other resources, into a single common PAK like file format
-
wunderkammer
Entity-Component storage for tiny games
-
bevy_generative
Procedural generation in Bevy
-
libthermite
managing Northstar mods
-
bevy_spectator
A spectator camera plugin for Bevy
-
bevy_mod_plotters
A plotter material for bevy
-
bevy_pxtxt
Create fonts and render text in bevy based on a bitmap source image
-
bevy_midi
Send and receive MIDI data to and from bevy and other programs or controllers
-
bevy-yoleck
Your Own Level Editor Creation Kit
-
saft
Signed distance field function compiler/interpreter/discretizer/mesher
-
bevy-paperdoll
Bevy plugin for 2D paper doll
-
foux
Foux Game Engine
-
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.
-
chron
A game loop with a fixed timestep
-
bevy_debug_log
Allows viewing tracing debug log output inside the bevy app using vanilla bevy_ui
-
bevy_2dviewangle
Bevy plugin for easier to switch texture base on view angles
-
beetmash_net
A lightweight Bevy replication library
-
quilkin
non-transparent UDP proxy specifically designed for use with large scale multiplayer dedicated game server deployments, to ensure security, access control, telemetry data, metrics and more
-
quake_log_parser_lib
A Sample Lib to Parse Quake Game Log
-
thallium
A basic game engine
-
inkling
Limited implementation of the Ink markup language
-
licheszter
An API wrapper for the Lichess API
-
landmass
A navigation system for video game characters to walk around levels
-
bevy-panic-handler
A Bevy plugin that creates a popup message and logs to error on panic
-
firefly_cli
CLI tool for working with Firefly Zero
-
fyrox-math
Math utils for the Fyrox engine
-
bevy_mod_observable_timer
An observer-based timer for bevy
-
thin-engine
A thin engine between glium, winit, glium-types and winit-input-map with some extra helper functions
-
bevy_window_title_diagnostics
Logs Bevy diagnostics into the primary window title
-
bevy_mod_reaction
Reactive components for Bevy
-
rsffish
wrapper for fairystockfish based on https://github.com/mind-sports-games/Fairy-Stockfish-Lib
-
macroquad-lua-cli
cli for macroquad-lua
-
seeded_dice_roller
A dice roller using a seed to give deterministic results
-
sculk
handling various data found in Minecraft's NBT files
-
bevy_tts
Text-to-speech for the Bevy game engine
-
bevy_vox
Load MagicaVoxel Vox file for bevy engine
-
revier-glam
Modification of the library glam-rs for the game engine Revier
-
bevy_replicon_attributes
Extends bevy_replicon with attribute-based visibility control
-
bevy_blender
Bevy library that allows you to use assets created in Blender directly from the .blend file
-
trecs
a tiny and easy to use ecs library
-
bevior_tree
Behavior tree plugin for Bevy
-
bevy_capture
A Bevy plugin for capturing frames from a Bevy application
-
bevy_mod_aseprite
A plugin for using Aseprite animations in Bevy
-
mun_target
Describes compilation targets for Mun
-
raylib-wasm
raylib native/wasm bindings
-
be_tween
Helper library to support tweening - with inital support for bevy
-
bevy_serialization_extras
managing serialization with moonshine_save + wrappers
-
naia-bevy-shared
faciliate naia & Bevy interop, functionality shared by client & server versions
-
botw-utils
various utilities for modding Breath of the Wild
-
hai_pal
Platform abstraction layer for Hai
-
bevy_vrm
Bevy plugin for loading VRM avatars
-
bevy_file_dialog
File system dialogs for loading and saving files using the Bevy game engine
-
shulkerbox
creating Minecraft datapacks in Rust
-
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
-
micro_bevy_world_utils
Handy, reusable utilities for working with direct world access in a Bevy exclusive system
-
bevy-fps-counter
FPS counter plugin for Bevy
-
swamp-app-examples
examples for swamp-render
-
quuidy
The simplest UUID v4 && v7 generation cli tool out there
-
sickle_ui_scaffold
Scaffolding framework for sickle_ui
-
bevy_simple_text_input
Bevy plugin for a simple single-line text input widget
-
uci
programmatically communicate with UCI compatible chess engines
-
hexlab
A hexagonal maze generation and manipulation library
-
uci-parser
Universal Chess Interface parser
-
ldtk2
A thin crate for people who just want to use ldtk files freely
-
bevy_embedded_assets
A Bevy plugin to embed assets in your game
-
dos-like
Framework for writing DOS-like applications
-
bevy_la_mesa
Build card games with Bevy
-
double_dot_state
State management crate built for the Bevy game engine
-
bevy_fly_cam
Flycam plugin for Bevy 0.14
-
ftvf
Temporal logic for writing a Fixed Tickrate, Variable Framerate game in Rust
-
bevy_sepax2d
Plugins and helpful methods for using sepax2d with Bevy for 2d overlap detection and collision resolution
-
dds-bridge
API for DDS, the double dummy solver for bridge
-
leafwing_abilities
A convenient, well-tested ability management suite. Built for the Bevy game engine.
-
irondash_engine_context
Easy access to FlutterView, FlutterBinaryMessenger and FlutterTextureRegistry for FFI
-
bevy_full_throttle
Enable CPU performance mode for Bevy games
-
coord_2d
A general purpose 2d coordinate
-
fmod-oxide
Zero cost bindings to FMOD and FMOD Studio
-
squirrel-rng
An impl of
rand::Rngbased on a talk by Squirrel Eiserloh re: Math for Game Programmers -
bevy_replicon_snap
High-level networking crate that extends the bevy_replicon crate to allow snapshot interpolation and client-side prediction
-
aline
2d linear algebra library suitable for no_std
-
bevy_ascii_terminal
terminal for rendering ascii in bevy
-
bevy_falling_sand
Falling Sand simulation plugin for Bevy
-
bevy_prototype_debug_lines
A prototype plugin providing a simple line drawing API for bevy
-
bevy_dither_post_process
A post-process black and white ordered dithering effect for the Bevy game engine
-
bevier
An interactive CLI to generate Games using the Bevy Game Engine
-
intrepid
Manage complex async business logic with ease
-
buffer-graphics-lib
graphics library for buffers
-
bevy_scroller
Scroller plugin for Bevy
-
mc_schem
read, create, modify and write various Minecraft schematic files
-
rafx-base
Rendering framework built on an extensible asset pipeline
-
bevy-persistent-windows
A Bevy plugin to easily create and manage windows that remember where they were
-
trs_24
An OpenGL-Powered Game Engine (OpenGL 2.0+)
-
chess-tui
A chess TUI implementation in rust 🦀
-
directx_math
translation of DirectXMath, a SIMD linear algebra library for use in games and graphics apps
-
gdnative_tweener
A port of DoTween(3rd party package for Unity) to Godot 3.5, using GdNative
-
fyrox-template
Project template generator for Fyrox engine
-
bevy_pkv
Persistent key value store for apps/games
-
acts
a fast, tiny, extensiable workflow engine
-
libikarus
The core functionality of Ikarus wrapped neatly in a rust library
-
edges
getting the edges of objects in images with transparency
-
bevy_copperfield
Procedural mesh editor, based on Half-Edge-Mesh datastructure
-
bevy-rapier-baseball-flight
Baseball flight simulation with Bevy and Rapier
-
steam-language-gen
Generate Rust bindings to Steam enums and messages
-
rust-training-tool
A very simple game engine using egui. Made for a rust training session, do not use!
-
bevy_mod_rounded_box
A rounded box shape for Bevy
-
realms
A powerful and lightweight graphics library for making Rust games
-
bevy_mod_sysfail
Decorate your bevy system with the sysfail macro attribute to handle failure
-
rust_airport_supplier
Rust-AirportSupplier downloads airport data from OurAirports and decodes the information
-
matrix_engine
a small game engine developed by drmatrix
-
pit-patch
Portal Interface Types
-
bevy_simple_preferences
Preferences API for Bevy
-
dod-table
A contiguous memory block (AKA a table) for Data Oriented Design
-
bevy_mod_bbcode
Use BBCode-formatted text inside of Bevy
-
bevy_submerge_ui
A ui plugin with tailwind like capabilities for bevy
-
gravitron
A GameEngine based on an ECS and Vulkan
-
bevy_tiling_background
A plugin to make tiling, layered, and parallax backgrounds for bevy2D
-
aeronet
Low-level networking for Bevy
-
tscale_sequence
generating tscale sequences
-
bevy_startup_tree
A bevy extension for inserting startup system dependency graphs into the app
-
hotline-rs
A high-performance, hot-reload graphics engine
-
bevy_serial
Serial Port Communication Plugin for Bevy
-
ploc-bvh
A Bounding Volume Hierarchy based on PLOC
-
posturn
Build turn-based games with
asyncRust -
bevy_tileset
configurable tilesets in Bevy using RON
-
lune-std-roblox
Lune standard library - Roblox
-
firewheel
Flexible, high-performance, and libre audio engine for games (WIP)
-
bevy_easy_compute
An easy way to run compute shaders for Bevy
-
bevy_mod_transform2d
A 2D Transform component for The Bevy game-engine
-
agb_tracker_interop
interop between tracker plugins and agb itself. Designed for use with the agb library for the Game Boy Advance.
-
bevy_2d_line
A line rendering plugin for Bevy
-
bevy_previous
Access previous values of components
-
evenio
An event-driven entity component system
-
bevy_wind_waker_shader
A toon shader that looks like the one used for characters in The Legend of Zelda: The Wind Waker
-
instant-glicko-2
Glicko-2 rating system that allows for instant feedback after games, not just once a rating period closes
-
bevy_mod_try_system
An extension trait for Bevy systems that return Results
-
bevy_mod_spritesheet
Create TextureAtlasLayouts from common sprite sheet formats
-
otter
game system; main data structures Rust crate
-
game_stat
handling stats that can change with modifiers, most commonly seen in games
-
gemini-engine
A 2D/3D monospaced ASCII rendering engine for the terminal
-
bevy_mesh_terrain
ergonomic heightmap terrain plugin for Bevy game engine
-
bevy_ort
bevy ort (onnxruntime) plugin
-
geo-bevy
Generate Bevy meshes from
geotypes -
ns_game
lib
-
edger_bevy_view
edger.dev view abstraction with common layout support
-
dfhack-remote
Interacting with the Dwarf Fortress remote API exposed by DFHack
-
bevy_map_camera
3D Camera Controller for Bevy
-
bevy_trickfilm
Bevy plugin for spritesheet manifest loading
-
bevy_eventlistener
Event listeners and callbacks for bevy
-
orthrus
A new way to modify games
-
inexor-rgf-core-builder
Inexor - Reactive Graph Flow - Core - Builder
-
bevy_simple_i18n
Bevy i18n plugin
-
bevy_fmod
Idiomatic FMOD in Bevy
-
magma_ecs
Entity-Component-System for the Magma3D game engine
-
bevy_serialport
async serial port Plugin for bevy
-
eframe_tao
egui framework - write GUI apps that compiles to web and/or natively
-
dcso3
Minimal Rust binding to the DCS lua api
-
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.
-
tiny-game-framework
Tiny game framework for creating games!
-
bevy_gltf_trait
Customizable Bevy Engine GLTF loading
-
csa
A Shogi game serialization/deserialization library in CSA format
-
pyxel-platform
Platform abstraction layer for Pyxel, a retro game engine for Python
-
boytacean-common
Commons library for Boytacen
-
gaviota-sys
Low level bindings for libgtb, a library for Gaviota tablebase probing
-
bevy_ratepace
bevy_ratepaceis a crate to configure the update frequency of headless bevy -
unreal_helpers
Tools for making and loading Unreal Engine Mods
-
ca-formats
Parsing pattern files for Conway's Game of Life
-
cargo-pixel
2d pixel art game engine & rapid prototype tools support terminal,sdl2 and web
-
bevy_vr_controller
VR character controller for Bevy
-
bevy_surreal
A Bevy plugin for SurrealDB integration. WIP not quite ready
-
bevy_easy_portals
Bevy plugin for easy-to-use portals
-
shogi_core
Fundamental types and functions for shogi
-
intuicio-data
Data module for Intuicio scripting platform
-
swamp-app
Application management for 2D pixel perfect sprite rendering
-
bhs
BHOP script for any game
-
reverie-util
reverie-engine
-
rantz_camera2d
A 2D camera plugin for Bevy, inspired by the Love2D camera plugin - STALKER-X
-
voxy
Voxel engine for Bevy
-
bevy-cross-gizmo
Adds
crossandcross_2dgizmos to Bevy -
bevy_round_ui
rounded-rect material shader for bevy_ui
-
bevy_blur_regions
A Bevy plugin to selectively blur regions of the screen
-
bevy_meshem
that offers a flexible and efficient way to generate meshes from a grid of Voxels
-
xwt
A common WebTransport interface for browser and native. Write once, run anywhere. Originally intended for use with bevy.
-
backgammon
The Rust Backgammon library
-
tetra
2D game framework written in Rust
-
polyanya
Polygon Any Angle Pathfinding
-
erupt-bootstrap
vk-bootstrap for Rust
-
ck3-tiger
Validator that checks Crusader Kings 3 user mod files for mistakes and warns about them. For example: missing localizations, or using a faith trigger on a character. Crusader Kings…
-
bevy_terminal_display
A plugin for the Bevy game engine which enables rendering to a terminal using unicode braille characters
-
bevy_simplenet_events
Event-based networking API built on bevy_simplenet
-
nate-engine
Fun High Level ECS Game Engine I Wrote
-
seldom_map_nav
Bevy plugin that does navmesh generation, pathfinding, and navigation for tilemaps. Navmesh generation is available without Bevy dependency.
-
strawberride
A Celeste map serializer and deserializer
-
naga-to-tokenstream
Creates a TokenStream describing parts of a Naga module
-
rparrett/taipo
A Typing Tower Defense Game for learning Japanese
-
bevy_query_ext
Extensions for Bevy's queries
-
unitypkg-core
Manipulate Unity's portable package files
-
rust-rpg-toolkit
An engine for creating action RPGs with Rust and/or JSON
-
bevy_quill
A reactive UI framework for Bevy
-
bevy_consumable_event
add events to Bevy that can be consumed
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
berdicles
Expressive CPU particle system for the bevy engine
-
xecs
An Entity-Component-System library
-
stourney
Splendor tournament manager - an app for running Splendor tournaments between autonomous agents
-
nimble-client
Nimble Client
-
bevy_fabulous
A Bevy plugin for enriching spawned GLTF scenes with gameplay components / assets
-
goggles
Building blocks for a hibitset based ECS library
-
entropy-base
entropy-game shared library
-
bevy_zeroverse_ffi
bevy zeroverse ffi library
-
hnefatafl
building software for the tafl family of board games
-
horfimbor-time
Time calculator for the Horfimbor game
-
shogi
Bitboard based Shogi library. Board representation, move handlings and various time control utilities.
-
bevy_icon_creator
A plugin to automatically create Icons from entities/models in bevy
-
bevy_c3d
A plugin for loading C3D motion capture files into Bevy
-
bevy_scene_postprocess
Bevy that provides a way to postprocess scenes after loading them
-
poker
speedy poker hand evaluation
-
fast-tak
abstract strategy board game Tak
-
inv-sys
effective inventory system for games
-
bevy_app
core App functionality for Bevy Engine
-
bevy_dyn_component
Safe dynamic components API for Bevy
-
bevy_egui_next
A plugin for Egui integration into Bevy
-
bevy_cleancut
Random utility stuff for bevy for my personal use. You're welcome to use it, too, if you like.
-
catgirl-engine-client
Client side part of the catgirl-engine crate
-
ftw
A CLI tool to manage your godot-rust projects!
-
bevy_coroutine
run coroutines in Bevy
-
some_bevy_tools
A collection of tools which can be used in the Bevy Engine
-
sceller
An ECS crate written in Rust based on the tutorial series by Brooks Builds on Youtube
-
bitt
Bevy integration testing toolkit
-
cosync
a single threaded, sequential, parameterized task pool for games
-
valve-server-query
This package allows you to access the data provided by Valve's Server Query protocol
-
noisy_bevy
Procedural noise primitives for Bevy
-
pixel-handler
Wrapper for the ggez game engine crate
-
planning
allowing the planning of minimal sequences of actions to achieve a goal state
-
com-croftsoft-lib-animation
CroftSoft Library for Animation
-
ici-files
Encode/decode ici files
-
valence
A framework for building Minecraft servers in Rust
-
rusty_sword_arena
Library/repository for the half-day Rust tutorial teaching you how to make a game client in Rust
-
daedalus
querying and parsing Minecraft metadata
-
raycaster
A multi-threaded raycaster engine for creating game graphics similar to Wolfenstein3D
-
bevy_koto
Koto support for Bevy
-
scion
Game making library on top of wgpu, winit, hecs
-
casino_cards
that provides a deck of playing cards that can be used for various card games
-
bevy_window_icon
Window icons in Bevy
-
wutengine
A modern game engine
-
bevy_wasm_window_resize
Bevy helper crate that makes application canvas match window size
-
bevy_render_layers_manager
Manager for Bevy RenderLayers
-
bevy_time_runner
General timing system for the Bevy game engine
-
bevy_oxr
Community crate for OpenXR in Bevy
-
bevy_outline_post_process
An adaptive outline post-processing effect for the Bevy game engine
-
bevy_text_popup
Easily create temporary text pop-up nodes in the Bevy game engine
-
iyes_loopless
Composable alternatives to Bevy's States/FixedTimestep/RunCriteria
-
bevy_mod_openxr
Community crate for OpenXR in Bevy
-
bevy_mod_lockdown
reduce the attack surface your application offers
-
zcomponents
stupid component storage
-
emd_earcutr
A fork of the https://github.com/donbright/earcutr repo
-
bevy_schedules_ext
A Bevy plugin for expanding the use of schedules
-
bevy_novel
Visual Novels with Bevy
-
bevy_local_commands
local shell commands for the Bevy game engine
-
epic-mickey-lib-rs
modding files for Epic Mickey (2)
-
hoi4save
Ergonomically work with HOI4 saves
-
rercon
RCON library with automatic reconnection support
-
ecs-tiny
A minimal ECS supporting entity and component insertion/removal, association, and single-type iteration
-
mapgen
Map generator for games (dungeons, worlds etc.)
-
buri
A game engine
-
skeletal_animation
Skeletal character animation library, using gfx-rs
-
beet_spatial
A very flexible AI behavior library for games and robotics
-
bevy_aseprite
Bevy aseprite loader
-
fmc_protocol
The fmc protocol
-
shakmaty-uci
Universal Chess Interface (UCI) message parser
-
bevy_cursor
A bevy plugin to track information about the cursor
-
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.
-
maze_rs
maze game in rust
-
tokyodoves
efficient board of Tokyo Doves and associated toolkits
-
perovskite_game_api
Multiplayer voxel game written in Rust - default game content + plugin API
-
allegro_util
Rust Allegro 5 wrapper utilities
-
notan_draw
2D API for Notan
-
macroquad-canvas
Adds canvas functionality to Macroquad
-
uni-app
native/wasm compatibility layer for window creation, input and filesystem
-
bevy-scene-hook
Ad-hoc component insertion for bevy scenes
-
ghx_grid
2D & 3D grid structures & utilities
-
retroboard
A chess retrograde move generator, suitable for endgame tablebase generation
-
uobors_cli
Unleash OpenBOR modding in Rust
-
bevy_egui_ime
plugin that supports Japanese input with bevy_egui
-
bevy-drpc
A bevy Discord RPC plugin
-
bevy_video_glitch
A video glitch effect for bevy
-
moecs
Micro ECS engine. A small and lightweight ECS engine for Rust projects.
-
godot-run
Run Godot projects from GitHub quickly and easily
-
kifuwarabe_tic_tac_toe
A small example before developing computer chess and computer shogi. Come see the repository.
-
bevy_testing
Testing library for bevy
-
radip
Diplomacy adjudication library
-
allegro_primitives-sys
Allegro 5 primitives addon Rust binding
-
bevy_text_edit
Bevy plugin for input text
-
impeller
Column-based protocol for transferring ECS data between different systems
-
ambient_std
Ambient standard library extensions
-
palkia
Entity Component Message architecture a la Caves of Qud
-
twothousand-forty-eight
a basic engine and move validator for the game 2048
-
springy
Stable springs for game development usecases
-
ira_cli
Command line interface for preparing assets for Ira
-
bvh-arena
A bounding-volume hierarchy for in-game broad-phase collision detection
-
gdextension-api
Godot GDExtension API; used by godot-rust
-
thomas
An ECS game engine
-
bevy_heightmap
Create meshes from heightmap PNGs in the Bevy game engine
-
bevy_mod_osc
OSC plugin for Bevy engine
-
bevy_orbits
A bevy plugin for creating stable orbits, and calculating transfers between them
-
bevy-hikari
Realtime Path Tracer for the Bevy Engine
-
caelunshun/feather-blocks
A Minecraft server implementation in Rust
-
bevy_crab_networking
Bevy plugin for sending data over TCP
-
bevy_mod_actuate
A reactive user-interface framework
-
bevy_flicker
An easy to use event-based system to apply brief overlays to sprites and meshes
-
crankstart
A barely functional, wildly incomplete and basically undocumented Rust crate whose aim is to let you write games for the Playdate handheld gaming system in Rust
-
bevy_debug_panel
show debug info to panel
-
dynec
An opinionated ECS-like framework
-
dorothy-ssr
The lib for building Dorothy SSR games in Rust running on target wasm32-wasi
-
kratka
Grid essentials to build upon for the Bevy engine (DRAFT)
-
kiwi-ecs
A performant, small and versatile entity component system
-
bevy_simple_networking
authoritative server networking library for Bevy
-
kingslayer
A text adventure dungeon crawler game written in Rust
-
libktx-sys
Rust bindings for libktx
-
rag-rs
rag
-
bevy_vulkano
Vulkano Backend for Bevy
-
better_button
Extend Bevy buttons with on-entered and on-exited events for press, hover and mouse over states
-
rubot
A generic game bot written in Rust
-
TerraForge
Lightspeed terrain generation at scale in rust
-
hammerspace
A plugin for the loading and management of levels and scenes, and their physical properties
-
morph3d
assimp alternative (obj, gltf & glb is supported). DAE, Stl and Usdz support is comming soon.
-
mctools
that contains some Minecraft tools
-
let-engine
game engine
-
bevy_gltf_save_load
Save & load your bevy games
-
farver
color library with easy transformation of colors with less functions
-
specs-hierarchy
Scene graph type hierarchy abstraction for use with specs
-
savesys
Variable-based save management system
-
bevy_pixel_camera
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
littlewing
A chess engine rated at 2050+ ELO, compatible with both UCI and XBoard protocols, with a nice CLI, and a documented library
-
strustle
A wordle clone to play in the terminal
-
bevyinit
An easy way to create projects with Bevy Engine
-
bevy-kira-components
Alternative crate for Bevy integration of Kira
-
firewheel-sampler
Sampler nodes for the Firewheel audio engine
-
re_math
An opinionated game math library built on top the excellent glam
-
bevy_ui_inspector
inspecting bevy ui
-
crystalorb
Network-agnostic, high-level game networking library
-
lyrebird
sound and music generation in bevy
-
meshopt-rs
Pure Rust implementation of the meshoptimizer library
-
bevy_intro_screen
Highly customizable introductio n(splash) screen library for Bevy games
-
moonshine-spawn
Collection of tools for spawning entities in Bevy
-
tuig
Flexible, portable, and fast game engine for textmode games
-
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
-
min_timer
f64 based duration and timer; moreover, a main loop implementation using it
-
zero_ecs_build
Build scripts for: ZeroECS: an Entity Component System (ECS), using only zero-cost abstractions
-
kurinji
Input map for bevy
-
world_dispatcher
System part of a full ECS, along with a fast dispatcher and world container
-
bevy_transform_gizmo
A 3D transform gizmo for Bevy
-
pons
Rust package for contract bridge
-
glicko_2
Glicko2 is an iterative algorithm for ranking opponents or teams in 1v1 games
-
simple-game-utils
games
-
bevy_match3
A logic library for quickly adding a match-3 system to any bevy project
-
bevy-aabb-instancing
Render millions of AABB instances in Bevy
-
event-simulation
event based simulation of application state
-
space-partitioning
Space partitioning data structures
-
edger_bevy
edger.dev shared logic for bevy applications and libraries
-
wutengine_editor
editor for WutEngine games
-
ggbasm
Generating Gameboy Assembler
-
zara
Zara survival engine
-
torchbearer
Find your path in darkerer dungeons
-
component_group
Defines the ComponentGroup trait for managing a group of specs::Component instances and moving them between specs::Worlds
-
oml-game
Game foundation extracted from Fiiish-RS to remove boilerplate for future procjects
-
bevy_animations
2d Game Animation Engine built for Bevy
-
cc6502
making C compilers for the 6502 8-bits processor
-
riichi
Japanese Riichi Mahjong game engine
-
luminol-data
Luminol's RPG Maker data structures
-
wow_spells
Spell definitions for World of Warcraft game servers
-
bevy_fake_interior
Fake interior material for Bevy
-
houtamelo_utils_gdext
A collection of utilities shared between Houtamelo's GDExtension projects
-
lwa_cargo_vacuum
CLI tool for cleaning up old target folders
-
raster-fonts
Bitmap font creation tool and accompanying metadata deserialization library
-
bevy_talks
A Bevy plugin to write dialogues for your characters to say and do things, together with player choices
-
raylib-rs
Rust wrapper for raylib
-
ruci
A UCI (Universal Chess Interface) crate
-
bevy_key_rotation
Access and refresh token rotation for Bevy applications
-
bevy_webcam_facial
Webcam AI face recognition plugin for bevy game engine
-
bufferbuffer
Double Buffer design pattern from 'Game Programming Patterns' by Robert Nystrom
-
hecs-component-provider
Easily define behavior for sets of components when using the hecs ECS library
-
hotham
A framework for creating incredible standalone VR experiences
-
piston3d-cam
3D camera and navigation
-
checs
An Entity-Component-System library
-
bevy_variable_property
A generic way to define properties as static, random, or randomized on an interval
-
siiir-bevy_fancy_cursor
Facilitates creating custom cursor in bevy-based app. Uses bevy’s
ImageBundleto replace the original cursor with moving UI element. -
ticktime
struct to convert a tick to an in game date time
-
bevy_state_ui
UI library for rendering a UI from a given state
-
rantz_proto
An opinionated rust library for transforming on-disk assets into Entities in Bevy
-
bevy_utilitarian
A collection of mostly maths, interpolation and geometric utilities that aim to make Bevy programmers happier
-
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…
-
bevy_2d_collisions
Bevy plugin to easily detect aabb collisions
-
bevy_parallaxation2d
providing simple 2D parallax layers in Bevy
-
hydrate
Game asset pipeline and authoring framework
-
pixel-game-lib
AGPL licensed and opinionated game engine for pixel-art games
-
ccdb
A small terminal based game engine
-
bscore
bowling score library for Rust
-
bevy_wasm_shared
Run WASM systems in Bevy
-
urex
wip UnityRustExtractor and patcher
-
asciivation_duty_renderer
in-terminal 3d renderer for a game i was/am writing, but that may also be useful as a standalone library
-
slowchop_console
A Quake style console and log plugin for Bevy
-
gyges_engine
A powerful Gygès engine
-
ambient_asset_cache
Asset cache for the Ambient runtime. Host-only.
-
cube-lib
魔方 核心库
-
bevy_fpc
First person controller plugin for the Bevy game-engine
-
macroquad-tiled
Tiled editor macroquad intergration
-
bevy_pipelines_ready
Bevy plugin for tracking render pipeline status
-
resonite
Resonite's API in rust
-
rglua
Toolkit for garrysmod development with the source sdk and luajit api
-
shogo
webgl game engine using offscreencanvas
-
kira_framework
OneBot 11 based on the ECS architecture
-
bevy_2d_menu_mask_transition
A Bevy plugin for creating smooth menu transitions with customizable masks
-
ghx_constrained_delaunay
2d constrained Delaunay triangulation
-
image-atlas
A texture atlas generator for generic purpose
-
big_space
A floating origin plugin for bevy
-
bevy_pixels
Bevy plugin that uses Pixels (a tiny pixel buffer) for rendering
-
bevy_ios_gamecenter
Bevy Plugin and Swift Package to provide access to iOS native GameKit (Gamecenter) from inside Bevy Apps
-
generational_vector
A vector type using generational indices
-
oxygengine-network
Network module for Oxygengine
-
bevy_query_macros
Bevy query macros
-
mun_abi
Rust wrapper for the Mun ABI
-
bevy_webp_anim
Plugin for loading and playing animated webp images in bevy
-
bscore-lib
bowling score library for C (written in Rust)
-
feo-oop-engine
An Object Oriented game engine for rust
-
bevy_scrolling_2d_camera
2d camera plugin for bevy supporting scrolling with right mouse dragging
-
bevy_enhanced_input
Dynamic and contextual input mappings for Bevy
-
durian_macros
Macros for the durian crate for ease of creating Packet structs
-
naia-bevy-server
faciliate naia_server & Bevy interop
-
prime-forge
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
bevy_cobweb_ui
UI tools and widgets built on bevy_cobweb and sickle_ui
-
bevy_fabrik
IK solver for Bevy using FABRIK algorithm
-
olc-pge
A reimplementation of the olcPixelGameEngine in Rust
-
ira_drum
A packaging format for textures and models
-
ldtk-codegen
Generate typed rust code from LDtk Project
-
throne
Game scripting language for rapid prototyping and story logic
-
bevy-avian-baseball-flight
Baseball flight simulation with Bevy and Avian
-
gbfs
reading gameboy filesystem archives, a format commonly used in GBA homebrew games
-
sg-sprite
Application for restoring Mages engine sprites (Steins;Gate, Steins;Gate 0, Chaos;Child)
-
specs
Entity-Component-System library written in Rust
-
overworld
Metapackage library for adding game systems useful for incremental, RPG, and management games
-
tdlg
Generates a grid of cells that could be used to build a top-down game map. Used by me to learn Rust.
-
solstack
Enables management of your app's or game's control flow through a simple state stack machine
-
firecore-battle
Pokemon battle simulation
-
bevy_animation_graph
Animation graph library for the Bevy game engine
-
bones_lib
The Bones game development library
-
bevy-discord-presence
Discord presence plugin for the Bevy game engine
-
bevy_foliage_tool
A configurable foliage painting system using perlin noise, grayscale maps, and chunked visibility
-
fixedstep
macro to create a fixed timestep loop for a game
-
roast2d
homebrew 2D game engine inspired by high_impact
-
reverie-engine
A toy game engine
-
rust-sokoban
sokoban game base rust
-
blocky-net
creating Minecraft clients, enabling packet manipulation and automated interactions with Minecraft servers
-
vertix
A cross-platform performant ECS game engine
-
gdnative_bindings_generator
Generates bindings for the Godot engine's gdnative classes from a json api description file
-
dces
DCES entity component system
-
mun_diagnostics
in-depth diagnostic information for compiler errors
-
mclr
run mc in rust
-
bevy-egui-kbgp
Better keyboard and gamepad story for egui in Bevy
-
doryen-extra
aims to be a loose re-implementation of the utility features from the popular roguelike library named libtcod
-
ayaka-primitive
Primitive types for Ayaka
-
rantz_random
Mostly just a wrapper around fastrand for a bunch of types. Supports bevy and rantz_spatial2d.
-
lightyear_examples_common
Common harness for the lightyear examples
-
bevy_channel_trigger
Send events via a channels form anywhere (eg. c-ffi) to Bevy Observers
-
bevy_gltf_components
Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side
-
ebb
An ECS-based game engine built on WGPU and Winit
-
play-games-services
Google Play Games Services Plugin for Crossbow
-
epicinium_lib
Rust bindings for libepicinium, the game logic library of the strategy game Epicinium
-
notch
A compact and fast library for managing Minecraft servers
-
box2d-rs
Port of Box2d to Rust
-
bevy-tnua-avian3d
Avian 3D integration for bevy-tnua
-
misc_ecs
basic Entity Component System library, being developed as a way to learn
-
tonytools
handling certain Glacier 2 formats
-
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.
-
bevy_more_shapes
Bevy engine plugin that adds additional shapes to the existing collection of procedurally generated geometry
-
bevy_crossbeam_event
Fire Bevy events from crossbeam channels
-
bevy-kenney-assets
Use kenney spritesheets as texture atlases in Bevy
-
bevy_rectray
A minimal 2d layout system for bevy
-
clige-rs
CLI Game Engine - clige
-
bevy-vfx-bag
An assorted bag of visual effects for Bevy
-
bevy_fpc_sprint
Sprinting feature for
bevy_fpc -
pleco
A blazingly-fast chess library
-
chessgen
Chess moves generator
-
xanadu
A toy ECS library
-
bevy_clay_tiles
A procedural-mesh building system for bevy
-
bevy_dexterous_developer_library
A modular hot reload system for rust
-
timeline_rs
timeline library for Rust
-
mime_more
better MIME function integrations
-
tego
loading Tiled maps
-
double_dot_macro
Macros for the Double-Dot crate ecosystem
-
kifuwarabe_connect_four
WIP. Connect-four AI. Currently, does not work.
-
bevy_ghx_grid
Bevy plugins for 2D & 3D grids
-
shogi_official_kifu
The official notation of shogi moves
-
lf-gfx
A collection of utilities that we use
-
mini_asset_loader
A composable game asset-loading system
-
tts-external-api
External Editor API for Tabletop Simulator
-
nnsdk
Cleanroom reverse-engineered bindings for nnsdk (Nintendo Switch SDK)
-
pokemon-synthesizer
A synthesizer for the sound format of the Pokemon GameBoy games
-
pyxel-wrapper
Python extension module for Pyxel, a retro game engine for Python
-
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)
-
elite_journal
Elite: Dangerous journal file stuctures and parsers
-
bevy_headless_render
A plugin for the bevy engine which enables headless rendering to an image for use in the main world
-
bevy_b3d
A Bevy extension for B3D loading
-
bevy_observed_utility
Ergonomic and Correct Utility AI for Bevy Engine
-
nimlib
Nim games: calculate nimbers and possible moves
-
monte_carlo
Preforms Monte-carlo tree search
-
bevy_dynamic_bundle
dynamic bundles for bevy
-
simple-game-engine
A minimal game engine inspired by the OLC Pixel Game Engine
-
audir
Low-level audio library
-
ramirezmike/quien_es_el_mechaburro
A game made in one week for the Bevy engine's first game jam
-
bevy_xr_utils
utils for bevy_mod_xr and bevy_mod_openxr
-
bracket-pathfinding
Pathfinding and field-of view utilities. A Star, Dijkstra. Part of the bracket-lib family.
-
ecs_rust
ECS in Rust
-
ico_memory
Experimental custom memory manager and handle-based resource manager
-
bevy_cronjob
helper to run cronjobs (at repeated schedule) in Bevy
-
swamp-wgpu-window
creating and managing a window with rendering surfaces using winit and wgpu
-
bevy_mod_chroma
A plugin for the Bevy game engine to allow control of Razer Chroma devices
-
bevy_aseprite_ultra
A Bevy plugin for directly loading spritesheets and animations from aseprite binary files with hot reloading support
-
ugli-raw
Game ENGine
-
nphysics_testbed3d
Testbed for the 3-dimensional physics engine in Rust
-
bevy_mod_stylebuilder
A set of fluent builder utilities for Bevy UI styles
-
moonshine-view
Generic Model/View framework designed for Bevy
-
service-locator
Thread-safe generic service locator
-
miratope
A polytope renderer and builder
-
bevy_stat_query
An over-engineered RPG stat query system for the bevy engine
-
bevy_svg_map
load SVG to bevy, adding properties based on the style
-
edict-proc-lib
Powerful entity-component-system library
-
game_features
Various helpful constructs for game development. See the github repository for detailed instructions.
-
bevy_ui_bits
A mingy and opinionated collection of UI components for Bevy
-
bevy_2d_screen_space_lightmaps
Lighting plugin for 2D games made in the Bevy engine. This plugin uses the screen space lightmaps technique
-
remodel
read, modify, and write Roblox objects
-
bevy_osc
Send and receive OSC data to and from bevy and other programs or controllers
-
sheep
Modular and lightweight spritesheet packing library
-
lpcg
A lib to generate character spritesheets based on LPC
-
bevy_screen_diags
An on-screen FPS display for bevyengine.org
-
rhythm-core
Core library for the rhythm games
-
blua
bevy lua integration for doing systems in lua
-
apparatus
A 2D game engine
-
unrust-inbuilt
Inbuilt types common between unity and bevy used by unrust
-
pyri_state
A flexible
bevy_statealternative -
horizon_logger
Color-coded logging system for Horizon game server
-
main_game_loop
collection for building a winit game loop
-
zengine_ecs
ZENgine's entity component system
-
cubi_vectors
Vector library
-
bevy_gltf_kun
Bevy glTF plugin using gltf_kun
-
libquickjspp-sys
QuickJSpp Javascript Engine FFI bindings
-
bevy_math
math functionality for Bevy Engine
-
casclib
An open-source implementation of library for reading CASC storages from Blizzard games since 2014
-
perovskite_server
Multiplayer voxel game written in Rust - Game server
-
bevy_cobweb
Reactivity primitives for Bevy
-
bevy_descendant_collector
Bevy crate to collect named entities into a single component
-
bevy_tiled_prototype
A plugin for rendering tiled maps
-
bevy_rts_camera
An RTS-style camera for Bevy
-
ryot_ray_casting
Implements ray casting capabilities for Bevy, crucial for interactive game mechanics like line-of-sight, fog, complex collision, etc
-
fluffl
A cross-platform multimedia layer that exposes opengl,sockets,and audio utilities for desktop and browser
-
voxel_engine
Public API for the octo voxel game engine
-
interpulse
interacting with pulseflow apis
-
crossbundle
Build and publish apps for Android/iOS
-
gamepads
access information about connected gamepads
-
bevy_poly_level
A 2d polygon-based level editor for bevy game engine
-
mesh_to_sdf_client
A mesh to SDF converter and renderer
-
bevy_trackpad_haptic
A bevy plugin for triggering trackpad haptic feedback on a mac
-
catgirl-engine-server
Server side part of the catgirl-engine crate
-
bevy_quick_response
A Bevy plugin for quick responsive behaviors
-
bevy_interact_2d
A Bevy plugin for 2d mouse interactions
-
wasm4fun-graphics
Graphics primitives and subsystems for WASM-4 fantasy console
-
ambient_schema
Ambient schema
-
ccdb_script
A small language to add in games for easy modding
-
chuot-packer
2D texture packing for the Chuột game engine
-
amethyst_tools
Game development tools for the Amethyst engine
-
ps2logo
PS2 Logo Decryptor
-
ayaka-runtime
Ayaka low-level runtime
-
bevy_mod_progress
Convenient, strongly-typed progress tracking
-
pagurus_tui
run Pagurus games on a terminal
-
kayak_ui
A UI library built using the bevy game engine!
-
bevy_xpbd_3d_parenting
Allows children of a
bevy_xpbd_3dRigidBodyto exert forces on their parents -
metropolis
A high level easy to use graphics renderer
-
newport_math
Math library that also works with spirv shaders for Newport engine
-
libsmallworld
behind the "smallworld" binary crate
-
forged-in-lost-lands
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
bevy_fortress
My personal helper library for Bevy
-
gl-from-raw-window-handle
creating an OpenGL context from a RawWindowHandle
-
discord_game_sdk
Safe wrapper for the Discord Game SDK
-
collision2d
2d collision detection library
-
a2s
Source A2S query
-
saft-sdf
Signed distance field function library
-
charred-path
Component-based Bevy plugin for tracking path and homotopy data for moving objects
-
bevy_skybox_cubemap
Cubemap-based Skyboxes for Bevy Engine
-
bevy-autoplay
Automated integration testing based on recorded play-testing sessions
-
gravitron_ecs
performant ECS for Gravitron
-
bevy_bulletml
BulletML library in Rust with Bevy game engine suppor
-
pak
data pak format for games
-
space_traveller
command-line game engine based on the MVC architecture, centered around cosmic space
-
pistoncore-event_loop
A Piston event loop for games and interactive applications
-
macademia
A realtime application/game engine written in rust
-
blackjack
popular casino card game Blackjack
-
dice_forge
A small crate to preform basic math using dice notation for random numbers
-
semeion
A generic 2D environment simulator
-
bevy_web_file_drop
Bevy plugin adding better support for drag and drop files in the web
-
heavyli_engine
A game engine based on 'OpenGL'
-
amethyst/space-menace
An action 2D platformer made with Amethyst game engine
-
ecstatic
Statically-typed ECS library
-
bruto
Artificial opponent to play the board game Quarto
-
mewo
Lightweight ECS
-
quicksilver
game framework for 2D games in pure Rust
-
bevy_mqtt
MQTT client for Bevy ECS
-
bevy_replicon_repair
Extends bevy_replicon with client-state repair for reconnects
-
poirebot
A chess bot engine written in Rust
-
spin_sleep_util
Utils using spin_sleep
-
second-music-system
Portable, open source video game music middleware
-
rafx-framework
Rendering framework built on an extensible asset pipeline
-
veccentric
Tiny 2D vector library
-
weasel
A customizable battle system for turn-based games
-
h_mat
A type-safe heterogenous matrix type
-
resurgence
A VM backend designed to be embedded in an application
-
golem
A (mostly) safe library for graphics programming
-
bevy_flurx_wry
mechanism to create a webview based on wry
-
nes_rust
NES emulator written in Rust
-
bevy_fsl_box_frame
A gizmo for manipulating an OBB via 3D picking
-
crayon
A small, portable and extensible game framework
-
bevy_camera_extras
containing a collection of utilities to making working with cameras in bevy easier
-
bevy_sun_gizmo
gizmo for directional lights in Bevy
-
bevy_titan
Bevy plugin for spritesheet manifest loading
-
are_we_touching
Collision Detection library
-
bevy-progressbar
Create multi sectons progressbars and use them in the bevy ui
-
bevy_bevy
Bevy support for Bevy
-
wasm4-common
Functionality used from proc_macro and regular libraries for WASM-4 bindings
-
resources
Safe store for one value of each type, with interior mutability
-
bracket-geometry
Geometry utilities. Rect, lines, circles, distance calculations. Part of the bracket-lib family.
-
ogmo3
reading and writing Ogmo Editor 3 projects and levels
-
fyrox-resource
Asset management crate for the Fyrox engine
-
hill_vacuum_shared
shared utilities among the other HillVacuum libraries
-
pistoncore-glfw_window
A GLFW window back-end for the Piston game engine
-
generational_array
A small package to handle generational arrays and prevent the ABA problem while reusing unused space
-
scene-graph
a fast scene-graph for games and animation
-
game_clock
clock for game (engines) that is simple to use and efficient
-
wecs
ECS lib for general use
-
typing_engine
A typing game engine for Japanese and English
-
spring-ai-sys
Bindgen bindings for SpringRTS games
-
nwn_nasher_types
parse and de/serialize the files from the nwn community tool, nasher
-
wolf_engine_input
A high-level input API
-
spirv-layout
SPIRV reflection utility for deriving Vulkan DescriptorSetLayouts
-
hanjie
A nonogram game engine using Bevy
-
nimble-protocol
Nimble Protocol
-
bevy_tweening_captured
Tweening animation plugin for the Bevy game engine
-
sprites7800
a companion tool of cc7800 generating C sprites/tiles code
-
inline_tweak
Tweak values directly from the source code
-
easytext
A dead simple, easy-to-use and basic text rendering library for wgpu
-
oxygengine
Oxygengine
-
arche-tape
archetypal ECS
-
bevy_erm
A entity relational mapper
-
bevy_stroked_text
A Bevy plugin for stroked text rendering
-
fabulist-core
A branching narrative engine
-
ggegui
egui for ggez
-
planck_ecs
A tiny but very powerful ECS framework
-
mod_plugins_resources
Reduce plugin boilerplate in the Bevy game engine
-
brick_bird
A colorful Flappy Bird clone written in Rust. Cross platform. Has own physic engine. Parallel.
-
wutengine_graphics
Graphics and rendering interfacing code for WutEngine
-
hai_ops
Operations inside Javascript runtime for Hai
-
dbsdk-rs
API for creating Rust games for the DreamBox fantasy console
-
tetrice
core functions of Tetris
-
fmc
creating fmc servers
-
bevy_light_field
rust bevy light field array tooling
-
effect-util
Effect Engine
-
nage
Not Another Game Engine; command-line text adventure engine
-
ren
easy to use graphics library
-
azalea-entity
Things related to Minecraft entities used by Azalea
-
bevy_rapier_collider_gen
generating bevy_rapier2d colliders, for bevy apps, from images with transparency
-
cute-dnd-dice
roll dices
-
dodgy_2d
ORCA, a local collision avoidance algorithm for 2D
-
bevy_yarnspinner
Bevy plugin for Yarn Spinner for Rust, friendly tool for writing game dialogue
-
bevy_sparse_tilemap
A Tilemap crate for the Bevy game engine with a focus on large map sizes and ECS sparse maps
-
ivy-vulkan
Low level vulkan abstractions for the Ivy game engine
-
source-demo-tool
WIP: a library for opening (editing planned) source engine demo files
-
ambient_color
Defines a color type for Ambient, as well as helper operations
-
bevy-web-resizer
Automatically resize your Bevy app on the web (wasm) to the size of the browser window
-
chatter
Translate a human-readable dialogue script into Rust
-
jeremychone-channel/invaders
game with the Bevy Engine
-
byond
interfacing with the BYOND game engine
-
alnilam-log
Alnilam Log
-
behavorix
behaviour tree libary that can be used with bevy
-
forky_bevy
Rust Utilities
-
eu4save
Ergonomically work with all EU4 saves (ironman and multiplayer)
-
bevoids
A bevy plugin that aims to make boids easy to add to your game, without comprimising in control
-
pyrrhic-rs
A pure-Rust library to probe Syzygy Tablebases within a chess engine
-
physfs-rs
Safe wrapper around PhysicsFs
-
chsl
2D Game Physics Engine supporting Joints/Constraints
-
bevy_adventure
A framework for building adventure games in Bevy
-
thallium_ecs
The ECS for the thallium crate
-
chess-lib
A chess movement generator library
-
bva_cli
Bevy Vach Assets CLI
-
smve
A voxel engine written in Rust
-
bevy-better-events
better events and related objects for bevy
-
bevy_replicon_renet
Integration with renet for bevy_replicon
-
bevy_plane_cut
A plane cut material for bevy
-
font-awesome
A typed manifest of constants of Font Awesome unicode code points
-
turbo_atlas_icons
A system for declarative ui icon rendering with Bevy
-
firecore-pokedex
A pokedex library
-
my-ecs
Entity Component System implementation
-
libreversi
A backend for reversi game with enemy AI using MiniMax Algorithm
-
rouler
A container-like system for generating dice rolls
-
micro_bevy_web_utils
patching various missing parts from Bevy web/touch support
-
ck3save
Ergonomically work with all CK3 saves (regular and ironman)
-
blizzard-engine
Blizzard Game Engine ❄️ is a modular ECS game engine
-
usi
handle type-safe communication with USI-compatible shogi engines
-
gdext_coroutines
Run Rust Async functions and Coroutines in Godot 4.2+ (through GDExtension), inspired on Unity's Coroutines design
-
regecs-codegen
Code generation macros for REGECS
-
godot-rust-cli
easy way to use Rust with your Godot project
-
web-sys-main-loop
main loop (or game loop) for web_sys windows
-
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.12!
-
bevy_spawn_fn
Awesome spawning experience for bevy
-
bevy_verlet
Verlet physics implementation in bevy
-
emf-core-base-rs
Idiomatic Rust wrapper of the emf-core-base interface
-
space_editor
Prefab editor for bevy game engine. Make levels/object templates with intuitive UI
-
bevy_incandescent
A 2d lighting crate for bevy
-
bevy_vox_mesh
A bevy engine plugin for loading magica voxel files directly in bevy as usable meshes
-
ldtk_easy
An easy to use LDTK library
-
test_lulu
A fun test_lulu game
-
naia-bevy-client
faciliate naia_client & Bevy interop
-
lua-shared
Really simple wrapper around lua_shared(_srv) that tries not to be a total burden when interfacing with gmod's lua
-
amethyst_physics
The Amethyst Physics engine interface
-
valve-sdk13-rng
A port of Valve's SDK13 Uniform random number generator in Rust
-
ron_asset_manager
A dead simple crate to manage Ron based assets which depend on other assets
-
bracket-state-machine
State management library for bracket-lib terminal
-
moonshine-kind
type safety solution for Bevy
-
ombre
Shadowy game and graphics library for Rust
-
billow
Wave Function Collapse implementation in Rust
-
gridit
2D grid library utilizing the fun of iterators
-
thephet/bevyroguelike
Roguelike game using Rust and the Bevy engine
-
bevy_octopus
ECS based networking library for Bevy
-
bevy_tiles
Bevy library for working with entities in grids
-
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…
-
steamworks-sys
raw bindings to the steamworks sdk
-
mono_lib
hacking mono applications
-
oxygen_suite
Oxygen Suite is a set of tools made with the Oxygen Game Engine to make assets
-
luminol-web
Web-specific code for running Luminol
-
devotee-backend
Backend library specification for the devotee project
-
uobors_core
Unleash OpenBOR modding in Rust
-
auto-traffic-control
A video game for programmers about air traffic control
-
ABC_Game_Engine
fast, and flexible Game Engine written in Rust, with simplicity in mind
-
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
-
specs-task
Fork-join multitasking for SPECS ECS
-
mage-core
An ASCII art game engine written in Rust
-
wgtr-ecs
ecs made for educational purposes and wgtr engine Started by using https://github.com/brooks-builds/improve_skills_by_building_ecs_library_in_rust rust course
-
bevy_serialization_core
contains the plugins/systems that bevy_serializations_extras relies on, + some misc wrappers
-
Clig
A CLI Game engine to make games in CLI
-
luminol-eframe
egui framework - write GUI apps that compiles to web and/or natively
-
roq-dec
A minimal crate for decoding ROQ video streams
-
coffee
An opinionated 2D game engine focused on simplicity, explicitness, and type-safety
-
liverking
Primal Man
-
bevy_animation_graph_editor
Animation graph editor for the Bevy game engine
-
ldtk
reading the LDtk 2D tile map format
-
arimaa_engine_step
A step based engine for the board game Arimaa
-
pabitell-lib
Interactive storytelling - core library
-
frame_counter
frame counter and limiter
-
bevy_jornet
Bevy plugin for Jornet - a social game server
-
bevy_easy_config
A Bevy plugin that allows you to easily define and instantiate config files
-
bevy_scoreboard
A very simple scoreboard plugin for Bevy
-
bevy_editor_pls_default_windows
In-App editor tools for bevy apps
-
notation_model
Fun notation - runtime models
-
nodui
An egui-based visual graph editor
-
qqx
3d library for rust based on OpenGL
-
pokemon-sprite-compression
dealing with compressed Pokemon sprites
-
moore-neighborhood
Calculates Moore neighborhoods (8-connected) for arbitrary ranges and dimensions
-
bevy_fps
A fist person shooter plugin for bevy
-
notan_backend
default backend for Notan
-
dmsdk
Rust-friendly wrappers around the Defold dmSDK
-
bevy_proto
Create config files for entities in Bevy
-
rival
A framework for creating computer players for turn-based games
-
bevy_fsc_point_cloud
Point cloud renderer for Bevy
-
bevy-wasm-tasks
integration of WASM tasks into a Bevy app for background processing
-
bottomless-pit
A very simple 2D rendering/game engine inspired by raylib
-
bracket-noise
Rust port of Auburn's amazing FastNoise library. Part of the bracket-lib family.
-
seldom_fn_plugin
Allows using Rust functions in place of Bevy plugins
-
billy
A small ECS libary written in Rust
-
mochi
A mobile game engine based on Gtk & Cairo
-
specs-physics
nphysics integration for the Specs entity component system
-
baba
Extremely simple library for games, inspired by love2d and raylib
-
entropy-ecs
一个虚拟世界
-
lichessbot
Lichess bot. Under construction.
-
epic_manifest_parser_rs
A lightweight, fast epic manifest parser made in Rust
-
igdb
Video Game Database Api
-
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.
-
hex-spiral
A single-coordinate 2D hex grid
-
egui
immediate mode GUI that runs on both web and native
-
axle_ecs
Axle's entity component system
-
bevy_health_system
A quick and easy way to add a health system to any entity of your bevy game
-
aspen-renderer
Rendering library for the Aspen engine
-
bobox214/kataster
A single screen space shooter developed in Rust with 'bevy' and 'bevy_xbpd'
-
stabilkon
Mesh builder for tile maps using using texture atlases
-
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
-
game4all/vx_bevy
🧊 Voxel engine prototype made with the bevy game engine. Serves as a playground for experimenting with voxels, terrain generation, and bevy.
-
unity-unpacker
A CLI utility for unpacking the assets from Unity's .unitypackage file
-
rustygba
GBA game development library, based on the "gba" crate
-
chess-lab
Chess library with multiple variants and FEN/PGN support
-
rymder
Unofficial agones client SDK
-
irrgarten
Small and easy to use library to generate mazes for games
-
playdate-lua
High-level Lua API built on-top of Playdate API
-
raylib-light
raylib bindings
-
aoaddons
creating addons for albion online game in multiple programing languages
-
bevy_editor_cam
A camera controller for editors and CAD
-
bevy_mod_static_inventory
Static inventory for Bevy
-
rantz_suite
A combined suite of tools provided by Rantz for use with the Bevy game engine
-
bevy_text_mesh
A bevy 3D text mesh generator for displaying text
-
thousand_birds_bevy_embedded_assets
A Bevy plugin to embed assets in your game
-
maikklein/unreal-ffi
Rust integration for Unreal Engine 5
-
castle-core
CastleCore - Core engine for Altenstein (and same projects)
-
flecs_ecs_sys
sys binding for C/CPP flecs ECS library https://github.com/SanderMertens/flecs
-
bevy-tnua-avian2d
Avian 2D integration for bevy-tnua
-
sunshine
A raycasting game engine built on miniquad
-
ambient_shared_types
Types shared between the host and the guest of the Ambient runtime
-
dialogos
A super simple dialogue system for Rust
-
scpcb_redux_mapper
A map generation for SCPCB Redux
-
geon
once and for all!
-
soku
Easy sudoku generation and solving
-
crow
A pixel perfect 2D rendering engine
-
kaige_ecs
Fork of the Legion ECS library, with some changes to make it more suitable for use in Kaige
-
yarnspinner_compiler
Compiler for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
bevy_decorum
A highly customizable window decoration plugin for the Bevy engine, inspired by tauri-plugin-decorum
-
auburn
Fast and simple physics library
-
nu-plugin-engine
Functionality for running Nushell plugins from a Nushell engine
-
world-map-gen
Command line tool and library to generate random game world maps for both Rust and WebAssembly
-
safe_ecs
ECS written in safe code
-
quarks
A general purpose engine. Not ready WIP
-
mineswipe
playing Minesweeper!💣
-
paddle
2D Game Engine for Rust on the Web
-
monstermaker_core
Core types for the Monster Maker ecosystem
-
clocked
A collection of tools for synchronizing asynchronous audio streams
-
kakistocracy
A pile of vaguely gamedev related code, governed by its least suitable and/or most unscrupulous programmers
-
steel-engine
The steel game engine core library
-
fiz
Fiz: Game Engine & Graphics Toolkit
-
bevy_skybox
A skybox from an image for bevyengine.org
-
tomb
A minimal crate that provides dice rolling mechanisms for games
-
astral-util
Astral Engine (WIP)
-
bevy_toon_shader
Toon shader for the Bevy game engine
-
fps_counter
A Frames Per Second (FPS) counter
-
bevy_states_utils
Small utils for bevy states, such as nested states and Gc
-
bevy_openai
event-driven plugin for Bevy that provides convenient access to the OpenAI API
-
swamp-window
Easily create and manage windows across multiple platforms for game applications, leveraging the power of the
winitlibrary -
bevy-nest
🪹 A telnet plugin for getting MUDdy in Bevy
-
namigator
Rust bindings for the namigator pathfinding library for World of Warcraft
-
component_storage
pack components based on type in continous arrays
-
kratka_ldtk
LDTK importing for kratka
-
bevy_2delight_anims
An fsm-driven 2d animation system that's _delight_ful to use
-
transvoxel-data
The tables necessary to implement the Transvoxel algorithm
-
quadify
Bevy plugin that integrates macroquad's windowing/rendering/sound API
-
bevy_ecs_markers
🏷️ Markers for Bevy ECS Entities
-
bevy-tick-timers
Tick based timers for Bevy
-
bevy_http_client
HTTP client for Bevy
-
korome
WIP game engine using glium
-
static_ecs
static entity-component system
-
yml_dialog
A very light base structure to implement an Rust Dialog using YML (file) format
-
intuicio-backend-vm
VM backend module for Intuicio scripting platform
-
black_grimoire
game engine
-
rovella
A game library that, at present, only consists of a windowing and events wrapper
-
bevy-firebase-auth
firebase auth for the bevy game engine
-
word_search
generate and display a configurable word search grid
-
raylib-project-generator
Generate rust raylib project to run in browser
-
acidalia
The game's game engine's engine
-
midpoint-ui
Midpoint is an AI and open-world first game engine. Editor is WASM, but compile target is native wgpu, not WASM.
-
lacking
A game engine/framework port from Go
-
vibha
text adventure live-loading
-
gdrust
interacting with gdnative-rust a little easier
-
bevy_nine_slice_ui
A nine slice/patch texture plugin for bevy ui nodes, works in wasm
-
shuftlib
A generic library for card games and related topics
-
lib_sens
that converts sensitivities between video games and synchronizes them to configuration files
-
bevy_tileset_map
An extension to bevy_ecs_tilemap, allowing for configurable tilesets, auto tiling, and more using the bevy_tileset crate
-
gdengine
Game design document creation tool
-
steel-shader
The shader for the steel game engine
-
maikor-vm-core
VM for playing Maikor games
-
lib_tictactoe_menace
Tic Tac Toe game with a Menace AI
-
bevy_toast
A bevy plugin to easily show toast notifications to the player
-
peter-engine
A game engine I (Peter Schmidt-Nielsen) am writing for myself -- I don't recommend you use it
-
obfuscate-integer
may stop most Cheat Engine (and other variants) program scanning for the relative address, and thus stop further modification
-
chessbored
a chess board with movable pieces that behaves like a chessboard on the table
-
blokus
game engine
-
perovskite_core
Multiplayer voxel game written in Rust - Implementation details shared between client and server
-
act2
Act 2 is a simple engine for making text-based adventure games using JSON
-
morkovmap
A data-driven, Markov Chain-based tilemap generator library and app
-
lmbr_build
Amazon Lumberyard (unofficial)
-
bevy_dice
Physics-based dice rolls for bevy
-
treasury-import
FFI for treasury importers
-
hexgame_rs
game Hex, a discrete full-information strategy game for two players
-
guimcaballero/bevy_rhythm
A small rhythm game implemented in Bevy, with an accompanying tutorial
-
vingt-et-un
A blackjack engine
-
roasted-core
Core library for Roasted game engine
-
gameloop
deWiTTERS game loop
-
bevy_ios_notifications
Bevy plugin to interact with iOS Notifications API
-
box_intersect_ze
Broad phase collision detection using Zomorodian and Edelsbrunner's hybrid algorithm (streamed segment trees with pruning and scanning)
-
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
-
victorem
UPD Game Server Framework
-
game-save-backuper
back up save data of some game server
-
swizzle_3ds
Swizzle images for the GPU on the Nintendo 3ds
-
notan_glyph
glyph's support for Notan
-
das-grid
2D grid library which serves as fundamental building block for any 2D game built on the concept of grid
-
bevy_script_api
Bevy API for multiple script languages, part of bevy_mod_scripting
-
bbggez
functions by the Brooks Builds community for the Rust game engine GGEZ
-
ogsolve
The program for solving octal games
-
aamp
Nintendo parameter archive (AAMP) files
-
mythoji
A minimal Rust crate that helps identify and display fantasy appropriate emojis
-
bevy_combat
A sci-fi battle simulation implemented in the bevy engine
-
salva2d
2-dimensional particle-based fluid dynamics in Rust
-
mc173
Minecraft beta 1.7.3 base data structures and logic for running a world
-
bevy_ehttp
A ehttp client plugin for Bevy
-
dmastorage
High-performance I/O for Linux based on DMA Buffers
-
bevy_heterogeneous_texture_atlas_loader
Load heterogenous texture atlases from a ron manifest
-
inle_diagnostics
Inle game engine - Diagnostics library. THIS PACKAGE IS MAINTAINED FOR PERSONAL USE ONLY AND IS SUBJECT TO NOT RESPECT SEMVER AND BEING BROKEN OVER TIME.
-
nimble-seer
Nimble Prediction
-
bevy_bundlication
Replication rules for bevy_replicon based on a bundle pattern
-
nimble-host-logic
Nimble Host
-
mmo
Libraries for building scalable game servers
-
bevy-alt-ui-navigation-lite
A bevy plugin to make implementing ui navigation in your game a piece of cake
-
wad
binaries for reading WAD files compatible with the Doom game engine
-
corrosion
A Magic: The Gathering rules engine
-
rokol
Rust bindings to Sokol
-
bevy_color_blindness
Bevy plugin to simulate color blindness
-
nzsc_core
The Official (Experimental) NZSC Core Library
-
srcconsole
interact with the source engine console
-
director
versatile, ergonomic state machine in Rust-lang
-
rmv-bevy-testing-tools
Testing-utilities for integrating rstest, insta, and speculoos with bevy
-
vigilant_lamp
Multi-target game engine / graphics library
-
flutter_engine_context
Easy access to FlutterView, FlutterBinaryMessenger and FlutterTextureRegistry for FFI
-
wyrd
an entity component system created for TimberWolf
-
uobors_infrastructure_database_seaorm
Unleash OpenBOR modding in Rust
-
machinery
safe wrappers for working with The Machinery game engine
-
edger_bevy_egui
edger.dev egui helpers
-
ecs_girvel_common
Common types for ecs_rs
-
bevy_app_compute
App compute plugin for Bevy
-
graphite_command
Command parsing and dispatch framework for the graphite_minecraft project
-
bavy
This package may become something, or it may remain nothing. Bavy is not Bevy, that is for certain.
-
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
-
ambient_rpc
RPC implementation for the Ambient runtime. Host-only.
-
chess-turn-engine
Chess turn engine library with all chess rules implemented. Can be used to implement a chess game.
-
bevy_interleave
bevy support for e2e packed to planar bind groups
-
bevy_simple_prefs
A small Bevy plugin for persisting multiple Resources to a single file
-
bevy_fighter
A mildly opinionated micro-engine for building 2D fighting games with bevy
-
gm-ffi
an interface between GameMaker and Rust
-
i-cant-believe-its-not-bsn
Tools for spawning entity hierarchies in Bevy
-
miru-gl
OpenGL bindings for my personal game engine
-
slot_machine
Bluejay Bonanza Slot Machine
-
oml-game-egui
Very tiny helper to use egui with oml-game
-
mem-rs
pattern scanning and abstraction for pointers in memory of running processes
-
libecs
Rust ecs design pattern
-
rrise-headers
A helper for Rrise, generating headers based on soundbank definition files
-
dexterous_developer_dynamic
A modular hot reload system for rust
-
source-engine-types
Rust types for Source Engine games
-
gw2lib-model
Models for gw2lib
-
bevy_webgl2
A webgl2 wasm32 render backend for Bevy Engine
-
bevy-aabb-instancing-011
Render millions of AABB instances in Bevy
-
bevy_plot
A Bevy plugin for plotting data and explicit functions
-
timberwolf
a high-performance 3D-focused game engine
-
ryot_tibia
Specializes in managing and integrating Tibia-specific legacy assets, tailored for games inspired by the classic Tibia
-
yurei
a WIP high level wrapper around bevy_rapier3d created to remove some of the boilerplate while prototyping 3d platformers with bevy
-
focus
The Focused Entropy game engine for 2D game development
-
bevy_mod_opacity
Hierarchical opacity for bevy
-
evalexpr
A powerful arithmetic and boolean expression evaluator
-
mgf
A 3D collision and physics framework for video games
-
bevy_mask_system
system architecture that utilizes functional programming principles to organize code. It primarily uses mask-based generics to structure systems.
-
quake-bspc
Asynchronous wrapper for running the Quake BSP compiler 'bspc' as a child process
-
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.
-
raylib-sys
Raw FFI bindings for Raylib
-
odin
👁️ Relentless seeker of knowledge
-
bevy_web_popups
Allows to trigger web/dom based popups/alerts and textinput in bevy
-
ellipsoid
2d cross-platform game engine
-
zengine_engine
engine functionality for ZENgine
-
fts_gamemath
collection of crates that provide basic building blocks for 3d video game math
-
sotora-game/sotora
[WIP] showcase game made in the Bevy game engine
-
shogi_legality_lite
Legality checking in shogi without tables
-
degen_toon_water
A toon water shader for bevy
-
generic_asset
A upgraded version of Tantans asset loading macro for bevy 0.12
-
wolf_engine_window
high-level window API for video games
-
yarecs
Entity Component System
-
game-grid
2D grid for prototyping games. Including easy parsing, indexing and iterators.
-
halite3bdk
Bot Development Kit for Halite III
-
wolf_engine_events
An event modules for Wolf Engine
-
godot-rust-cli-upgrader
A CLI tool to help you upgrade your Godot Rust CLI project between versions that introduce breaking changes
-
muds
Minimalistic Data Structures and Entity-Component-System Library
-
gdnative-bindings
The Godot game engine's automatcally generated bindings to Godot classes
-
bevy-topdown-camera
3d topdown camera for Bevy
-
poll-reactive
A minimalistic poll-based reactive library
-
stringid
Lightweight system to manage identifier as human readable string and unique number
-
bevy_replicon_quinnet
Integration with bevy_quinnet for bevy_replicon
-
bevy_clap
A bevy plugin to parse CLI arguments with clap
-
cogs-gamedev
Common, Obnoxious Game Stuff. Contains a bunch of useful boilerplate for writing games.
-
mc-launchermeta
providing types for the Minecraft Launcher Metadata API
-
bevy_quit
plugin to easily add keybinds to exit a bevy game
-
dds-bridge-sys
Generated bindings to DDS, the double dummy solver for bridge
-
render-to-texture
Render to a texture using Bevy and optionally retrieve the contents in the Main World
-
libfj
An unofficial collection of APIs used in FreeJam games and mods
-
bevy_rollback
A rollback library for the Bevy game engine
-
fyroxed_base
A scene editor for Fyrox game engine
-
dotrix_pbr
Physically based rendering for Dotrix 3D Game Engine
-
set-with-grab
The macro to set state with error handling in bevy
-
digu
engine written in rust
-
minedmap-nbt
MinedMap's handling of Minecraft NBT data and region files
-
olc_rust_game_engine
beginner's port of a console game engine
-
rg3d-resource
Asset management crate for the rg3d engine
-
ff-particles
A fork of macroquad-particles with serde support
-
bestagon
An engine for discrete stuff in hexagonal grids
-
bevy_render
rendering functionality for Bevy Engine
-
game_of_life_bevy
Conway's Game of Life in bevy
-
bevy_fnplugins
A plugin for bevy that allows you to use functions as plugins
-
bones_ecs
flexible Entity Component System
-
playt
game library for the terminal
-
bevy_auto_update
Add automatic updating to your Bevy game
-
bevy_vinox_pixel
A package for creating pixel games in bevy
-
rustpak
Rust library/tool to manage GoldSrc .pak files
-
fontstash
wrapper of a forked version of fontstash
-
bevy_schedule_dispatch
Use equivalent functions to dispatch bevy ecs schedules
-
gdnative-async
Runtime async support for godot-rust
-
dotrix
3D Game Engine
-
deckofcards
An API to implement a deck of cards
-
bevy_retrograde_text
Bevy Retrograde's text rendering implementation
-
tecs
TeaECS, a simple ECS
-
bakkesmod
Rust SDK for writing BakkesMod plugins
-
rafx-renderer
Rendering framework built on an extensible asset pipeline
-
bbecs
ECS library for Brooks Builds projects made live on Twitch at https://twitch.tv/brookzerker
-
console_renderer
A console renderer for the ABC Game Engine
-
vulkust
Game engine
-
bevy_liquidfun
A Bevy friendly wrapper of Box2D and LiquidFun
-
bevy_procedural_grass
A plugin for bevy to generate grass
-
psvr
interfacing with the PlayStation VR
-
geng-ui
Game ENGine
-
pseudo_term
Window and graphical object-manager for making ASCII-art games
-
logtra
A minimal logging library
-
tetris_core
Tetris game model with no UI or Game engine
-
bevy_twitch_minimap
bevy plugin for interacting with twitch minimap extension
-
ultimate-ttt
Ultimate Tic Tac Toe - Game engine
-
zengine
2D ECS game engine
-
piston-ai_behavior
AI behavior tree
-
graphite_minecraft
crafting high-performance Minecraft servers
-
macroquad-virtual-joystick
joystick for macroquad games
-
simple-cards
deck of cards library with some useful functions
-
valence_inventory
Inventory support for Valence
-
wgsl-minifier
A command-line tool for minifying WGSL shaders
-
polako
Define the Bevy tree with
eml!, style it using a very-css-likeesssyntax and relate data data withbind!andconnect! -
kart-graphics-engine
a graphics engine using gl, glfw, and cgmath for 2d and 3d games
-
seawater
A high performance entity component system useful as a backend for developing GUI applications and video games
-
island_map_generator_algo
Generation crate for an island map editor using procedural generation, Rust and Bevy engine
-
unrust/unrust
pure rust based (webgl 2.0 / native) game engine
-
keeshond
A fast and fun 2D game engine for Rust
-
wasm4fun-sound
Sound primitives and subsystems for WASM-4 fantasy console
-
gsfw
tiny game server lib
-
steel-common
The steel game engine common library, depended by both steel-engine and steel-editor
-
turbulence
Tools to provide serialization, multiplexing, optional reliability, and optional compression to a game's networking
-
bevy_event_modifiers
Event modifier pattern for Bevy
-
rg3d
3D Game engine
-
doryen-fov
A pure rust library containing 2D field of view algorithms for roguelikes
-
bevy_dragndrop
implementing drag and drop functionality much easier for the bevy ECS engine
-
unrust
side of the unity package to work with rust + bevy in unity!
-
bevy_mod_auto_exposure
An auto exposure plugin for Bevy
-
comfy-ldtk
LDTK editor support for the Comfy Engine
-
libmancala
A frontend-agnostic library that implements the game of Mancala
-
bevy_spawnable
tiny spawn utility for Bevy, to encapsulate spawn logic
-
bevy_asepritesheet
Allow use of animated exported asetprite sprite sheets in bevy game engine
-
bevy_prototype_schedule_states
Bevy plugin for states as schedules
-
boids_rs_bevy
Rust boids simulation using Reynolds model running with Bevy engine
-
xonix
Remake of the old pc game xonix written in Rust and based on macroquad engine
-
amethyst-console
imgui frontent to cvar
-
ayaka-plugin-wasmer
A plugin runtime for Ayaka, based on Wasmer
-
pecs
Asynchronous operations for Bevy Engine
-
bloke
A video game avatar system, similar to Nintendo's Mii - but open source and for PC / phone games
-
bevy_ergo_plugin
Macros to make building bevy plugins more ergonomic
-
kusa_pixel
A pixel art painter for people who are sick of GUIs
-
dogoap
-
storm
A personal 2D game engine designed for performance
-
usi-run
A command line utility for running games between USI compliant Shogi engines
-
rg3d-ui
Extendable UI library
-
arbor
A generic interface to the Monte Carlo Tree Search algorithm
-
bevy_shape_draw
A shape drawing tool for Bevy
-
intfic
An interactive fiction framework written in Rust
-
kratka_bevy
Bevy integrations for kratka
-
oxygengine-input
Input module for Oxygengine
-
mun_paths
convenience structures for handling relative- and absolute paths
-
convchain
Bitmap generation from a single example with convolutions and MCMC
-
bevy_console_parser
console command parser for bevy_console
-
alkyd
bevy crate for handling procedural textures and shaders
-
aeronet_proto
Sans-IO protocol implementation for aeronet
-
mooeye
A small UI library designed on top of the ggez game library. WORK IN PROGRESS
-
bevy_lospec
Asset loader plugin for Bevy that adds support for lospec color palettes
-
android_base
A base for making android applications in rust with piston and glutin-window that simplifies android development
-
gerrymander
Push-down state automata for games
-
fps-controller
fps stabilizer for eventloop
-
pi_ecs_old
ecs
-
action_maps
A dynamic action mapping system for Bevy
-
catgirl-engine-utils
catgirl-engine crate
-
bevy_background_compute
Bevy plugin for better task handling
-
sungod
0-Dependency random numbers to brighten your day
-
bevy_cursor_hovering_sprite
a very lightweight plugin for bevy engine to check if a cursor is hovering on one 2d sprite
-
edger_bevy_shape
edger.dev drawing 2D shapes easily
-
blue_engine_utilities
Blue Engine
-
squares-rng
Squares RNG for game development
-
bevy_web_asset
Implementations for http(s) asset sources for Bevy
-
bevy_registry_export
Allows you to create a Json export of all your components/ registered types of your Bevy app/game
-
definitive
final vector & matrix library for Rust
-
swarm_pool
Optimized object pooling system for Rust
-
physics2d
2D physics engine, but with Iron power
-
jelly_ecs
but functional ECS
-
seldom_interop
Interoperability traits for Bevy components
-
bevy_ghx_utils
shared bevy utilities
-
bevy_entity_system
Adds systems that only operate on single entity
-
firewheel-extra
Extra nodes for the Firewheel audio engine
-
bevy_window_management
managing window icon and taskbar progress indicator in Bevy
-
bevy_mod_kira
A plugin that integrates the Kira audio library for use in the Bevy game engine
-
goblocks
Lua game engine based on Raylib
-
bevy_iced
Iced integration for Bevy
-
bevy-egui-notify
notifications library for EGUI, in the bevy system
-
nimble-step
Nimble Step
-
bevy_mod_wanderlust
A character controller library for Bevy Engine
-
mighty-mancala
A Text User Interface Mancala Game
-
zero_sum
An analysis engine for zero-sum games with game implementations
-
bevy_mod_gizmos
Visual gizmos to aid with development and debugging in Bevy
-
diceroll
dice rolling lib for RPG purposes
-
bevy_mod_inverse_kinematics
An inverse kinematics plugin for the Bevy engine
-
bevy_physimple
2d physics engine for bevy based on physme
-
text_adventure
a program to allow for the creation of simple text adventure games using JSON files
-
generic_game
A generic game engine library
-
ggez-goodies
Various small useful add-ons for the ggez game framework
-
swamp-wgpu-sprites
wgpu sprite utility functions
-
nova-r8
comprises Rust bindings for the Nova r8 game engine
-
tinyecs
Tiny entity component system
-
bsp
load BSP files efficiently - currently only works for Quake 3 BSP files. Fork of
quake3_loadercrate. -
bowtie
2D Game engine with messaging system
-
cvars-console-fyrox
In-game console for the Fyrox game engine, using the cvars crate for configuration
-
bevy_jpeg2k
JPEG 2000 image loader for Bevy
-
oxygen_core
Oxygen Core is the central part of the Oxygen Game Engine
-
newport_os
Os abstractions for engine use
-
tja
TJA file parser
-
elikar
asynchronous ECS game engine
-
schminput
An Action Based Input Manager for Bevy
-
chess-move-gen
Fast chess move generation library. Uses SIMD for fast sliding piece move generation
-
bevy_ogle
A multi-mode camera library for 2d vector games
-
bevy_replicon_spawn
Bevy replicon spawn event
-
covalent
name available
-
bevy_diagnostic_visualizer
Visualizations for Bevy game engine diagnostics
-
imperator-save
Ergonomically work with Imperator Rome saves (debug and ironman)
-
bevy_mod_scripting_lua
Necessary functionality for Lua support with bevy_mod_scripting
-
riichi-elements
Building blocks of Japanese Riichi Mahjong
-
celtic-names
A celtic name generator
-
otter-base
Otter game system; WASM/hostside common code crate
-
dos-like-sys
Low-level bindings to dos-like
-
beet_net
A very flexible AI behavior library for games and robotics
-
shogai
A shogi helper
-
bevy_pause
A very simple pause plugin for Bevy
-
bevy_wry
A tauri-apps/wry integration with Bevy engine
-
bevy_dioxus
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
bevy_two_entities
A few convenience traits for working with Bevy Queries
-
gox
loading Goxel .gox files
-
ionic_deckhandler
deck creation and card shuffling library
-
gb-sym-file
A parser for Game Boy sym files, fully conformant to the spec
-
pulz-schedule
For scheduling systems and managing their resources
-
dedenne
Cute little generators using async/await in stable rust
-
bevy_u8_assets
Allows one to write u8 bytes of an asset with a fake file path to bevy
-
luminol-ui
Luminol's UI code
-
thrustengine
a 3d graphics engine
-
physxx
Wrapper around the PhysX C++ API that aims to preserve the original API as much as possible
-
bevy_mouse_tracking_plugin
A plugin for effortless mouse tracking in the bevy game engine
-
basis-universal-sys
Bindings for the basis-universal Supercompressed GPU Texture Codec by Binomial
-
bevy_double_res
Straightforward double buffering implementation for bevy resources
-
gamevecs
that provides 2d and 3d vectors specifically for game developement
-
tnaps
entity-component-system framework in Rust
-
pmd_message
that can read message*.bin files, used in 3ds pokemon mystery dungeon games
-
sarc-rs
parsing and creating Nintendo SARC files in Rust
-
sprite-gen
Procedurally generate pixel sprites library
-
nimble-blob-stream
Nimble Blob transfer over datagrams
-
gsa
Game development library modelled after an imaginary console
-
vampirc-io
asynchronous, non-blocking, UCI protocol–based communication between chess UIs and chess engines
-
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.
-
rayngin
3D 6DF framework/engine for approach&click quests in rectangular chambers with objects consisting of balls
-
bevy_ui
A custom ECS-driven UI framework built specifically for Bevy Engine
-
gl-capture
Capture screenshot in OpenGL
-
pf_sandbox_lib
Data structures and helper code for PF Sandbox
-
unity-native-plugin-sys
-
sath
Toy math library
-
play-billing
Google Play Billing Plugin for Crossbow
-
bevy_smooth_pixel_camera
Smooth pixel-perfect camera for Bevy
-
z-buffer-game
Survival/strategy game with ascii-art graphics
-
bevy_yarnspinner_example_dialogue_view
Example dialog view for Bevy Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
jam_theme_picker
A Bevy + mdbook enabled template repo to build on
-
bevy_touch_camera
Touch camera for Bevy that supports drag and pinch to zoom
-
basic_bevy_pixel_camera
set of coponents, schedules, systems and helper functions to create any type of pixel camera
-
wgtr-scene-manager
scene manager with easy to understand functions
-
asefile
loading Aseprite files
-
buttons
API for storing and querying input state
-
rapier3d-lijay
3-dimensional physics engine in Rust
-
reverie-engine-opengl
A toy game engine backed by OpenGL
-
u64-id
A tiny library providing a u64 backed id
-
hextile
Handles coordinate math and other logic for hexagonal game maps
-
plushy
Comfiest generational arenas for Rust
-
indeedee
Distribute iterated work over multiple frames
-
bevy_simple_pixel_camera
An epic crate
-
evaluroll
A dice expression parser and evaluator
-
rusticify
App for brainstorming & sharing ideas 🦀 Learning Project
-
mathf
Math crate for Godi Game Engine
-
rs-tiled_json
A helper library to load JSON-formatted Tiled maps
-
freestuffapi
Freestuffbot API
-
rect_packer
A rectangle packing library. Heavily tested with random data to ensure that it always produces correct result.
-
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…
-
bevy-fps-ui
Fancy FPS counter for Bevy Game Engine
-
blunders
UCI chess engine application
-
widgetui
A bevy like widget system for ratatui and crossterm
-
tiny_die
A tiny lib crate for tiny dice
-
oasis-game-core
The core Oasis Game SDK engine
-
vek2d
2D Vectors
-
amethyst_lyon
Amethyst Lyon crate
-
wolfengine
Wolf is a set of modules for realtime rendering, realtime streaming and game developing
-
playdate-sys
Low-level Playdate API bindings
-
caption-compiler
Compiles and describes Valve's closed caption files
-
essentia-rs
Alchemical Simulation Engine loosely inspired by the real world
-
smol-layout
a small layout utility for very simple pixel art games
-
bevy-simple-state-machine
A rudimentary animation state machine system for Bevy
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
enco
entity-component library (not an ECS library!) for small projects
-
ambient_dirs
Directories that Ambient uses to store its data
-
reactor_spatial
A set of 2D spatial utilities for Bevy, including handling transform propagation
-
bevy_ui_forms
A bevy plugin for creating forms
-
bevy_puffin
Integration layer between Bevy, puffin and tracing
-
lunara
A work-in-progress, postmodern game engine
-
overworld_dice
Overworld Dice Library - Dice components
-
delos
An opinionated engine for building games in Rust
-
bevy_picking_core
A modular picking plugin for Bevy
-
ivy-collision
3D collision crate for Ivy
-
ambient_time
Helper functionality for manipulating datetimes
-
graphite_server
Minecraft server implementation for the graphite_minecraft project
-
bevy-translation-table
A super basic translation table system for bevy supporting generic data, CSV, and ODS
-
notan_log
multipatform log support for Notan
-
wutengine_opengl
The OpenGL backend for WutEngine
-
chunked
An Entity Component System that works by organising like entities into chunks
-
chickenwire
representing and manipulating hexagonal grids
-
gameloop-timing
Timing utilities for gameloops & mainloops
-
swamp-message
message container
-
bevy_sparse_grid_2d
Wrapper around a 2d hash map made for collision broadphase
-
street_fighter
16 bits Street Fighter 2 game engine
-
mycraft
A custom Minecraft server framework
-
quantic
A game engine written in rust for rust and compiles to wasm
-
ramirezmike/not_snake
A snake-inspired game made in Rust using the Bevy game engine
-
tge
A lightweight cross-platform 2D game framework written in pure Rust and based on OpenGL 3.3+
-
go_core
Part of Griffsort game
-
cheats
A game shell backend
-
gmath
math for graphics and games
-
theobserver
read pen pressure using evdev
-
gltf_kun_vrm
VRM extensions for gltf_kun
-
bevy_eventwork_mod_websockets
A Websocket NetworkProvider for Bevy_eventwork
-
bevy_bundletree
Spawn trees of bundles in the Bevy game engine
-
bevy-codex
A manager for menus and huds with the bevy game engine
-
prongs
Input handling schema written in rust. Backend agnostic, provides serializability, assignment and unified interface for working with inputs. Keyboard, mouse and controllers supported.
-
amethyst-imgui
imgui library for amethyst
-
pyri_tooltip
Powerful tooltips for Bevy
-
emf-core-base-rs-ffi
Rust wrapper of the emf-core-base interface
-
rafx-visibility
Rendering framework built on an extensible asset pipeline
-
morristown
working with https://github.com/coding-horror/basic-computer-games
-
bevy_tiled_camera
A camera for rendering low resolution pixel art in bevy
-
bevy_diagnostics_explorer
Bevy plugin that provides provides diagnostics into VSCode extension
-
conniecs
ECS system based off of the
ecscrate, but with some minor API adjustments and derive macros for implementing most of the boilerplate. Make sure to include theconniecs-derivecrate as well -
tm-sys
FFI bindings for the machinery api
-
texture
Micro-engine for creating text-based adventures
-
salva3d
3-dimensional particle-based fluid dynamics in Rust
-
rcocos2d-sys
Raw FFI bindings to RobTop's modified version of cocos2d v2.3.3
-
extol_image_font
Render pixel fonts from PNGs in Bevy
-
mun_syntax
Parsing functionality for the Mun programming language
-
coin_toss
minimalist library for coin tossing
-
godot_egui
Egui backend for the Godot Engine
-
softbuffer
Cross-platform software buffer
-
bevy_ui_extras
containing a collection of utilities to make working with ui in bevy easier
-
dodgy_3d
ORCA, a local collision avoidance algorithm for 3D
-
blend-rs
read Blender's .blend files
-
astral-engine
Astral Engine (WIP)
-
bevy_shader_graph
Shader graph for Bevy
-
libloadorder-ffi
A wrapper library providing a C FFI for libloadorder
-
drumbeat
An event handling system aimed towards real-time applications such as GUIs and Game Engines
-
hnefa
An engine for tafl-style games
-
witchcraft-renderer
A renderer for the Witchcraft game engine
-
bevy-trait-resource
Get resources by trait
-
lingon
A game engine mainly intended for use in game jams
-
mc-repack-core
repacking Minecraft mods and resource packs to optimize size and loading speed
-
anduin
Complex end to end game engine with usage of new technologies like vulkan api (vulkano), and basic principles: 1) Speed; 2) Memory Safety; 3) Cross-platform; 4) User Friendly
-
bevy_single
Package allows more convinient access to single entity from bevy query
-
bevy-yoetz
A decision-making AI for the Bevy game engine
-
playdate-system
High-level System API built on-top of Playdate API
-
gdvariants
Rust std library collections wrapper that implements the godot-rust variant traits
-
mun_capi_utils
Common functionality between C api crates
-
fumarole
2d engine
-
krust_core
krust core
-
luminol-graphics
Luminol's graphics backend, used for rendering sprites and tilemaps
-
san-rs
parsing standard algebraic notation (SAN)
-
naia-serde
Bit-level de/serialization for naia
-
bevy_component_extras
containing QOL bevy components for common features that other crates might want to interface with
-
rhusics
Physics library for use with
specs -
namigator-sys
Direct bindings for the namigator pathfinding library for World of Warcraft
-
qwac
Rust client crate for making qwac games
-
reason-othello
An Othello library with a blazing fast bitboard
-
franim
A frame animation library for
no_stdgame-development -
game_engine_core
The main loop of a game engine
-
unrust-codegen
The csharp codegenerator used by unrust
-
macroquad-platformer
Platformer physics for macroquad
-
kludgine-app
Application and Windowing for Kludgine
-
bevy_picking
screen picking functionality for Bevy Engine
-
ryot_pathfinder
specialized pathfinding functionalities for Bevy 2D, essential for dynamic navigation and movement within games
-
opensimplex2
Port of OpenSimplex2
-
merosity
(wip) competitive stacker game
-
spirit_edit_core
spirit editor
-
rgs_models
querying game servers. Models.
-
wolf_engine
A game framework with a focus on flexibility and ease of use
-
uasset
Parsing of Unreal Engine asset files (uassets)
-
bevy_rng
A Bevy game engine random number generator plugin
-
rrise
binding for Wwise
-
bevy_mod_chroma_request_lib
Request lib for bevy_mod_chroma
-
intuicio-frontend-assembler
Assembly frontend module for Intuicio scripting platform
-
bevy_ghx_proc_gen
Bevy plugins for 2D & 3D procedural generation with WFC/Model synthesis
-
godot-rs-config
Command line tool to generate Godot Extention config
-
fndg
An unchained map game where you battle for resources while building your nation up
-
gee
A convenience-first geometry library tailor-made for 2D games! 📐
-
machinery-api
Generated API types for The Machinery game engine
-
bevy_dexterous_developer_dynamic
A modular hot reload system for rust
-
y-craft
Craft your dream 2D gaming experiences with the X-Craft engine
-
rojo
Enables professional-grade development tools for Roblox developers
-
bevy_spicy_networking
A spicy 🌶🌶🌶 and simple networking plugin for Bevy
-
leafwing_input_playback
Input recording and mocking functionality for the Bevy game engine
-
bevy_register_in_world
Register types into the world during runtime
-
entity_store_helper
simplify using code generated by entity_store_code_gen
-
pagurus_game_std
The standard library to develop Pagurus games
-
discord_game_sdk_sys
Low-level bindings for the Discord Game SDK
-
tiled-json-rs
parse and interact with Tiled editor JSON files
-
wunderkammer_derive
Derive macros for the Wunderkammer crate
-
simple-tilemap
tilemap & tileset implementation
-
bevy_http
Bevy HTTP asset loader plugin
-
advancedresearch-nano_ecs
A bare-bones macro-based Entity-Component-System
-
rsaarelm/magog
Roguelike game
-
shogi_usi_parser
Conversion from strings in USI format
-
chargrid_graphical
Graphical chargrid context
-
bevy_input
input functionality for Bevy Engine
-
bevy_simple_scroll_view
plugin implementing ScrollView into Bevy engine
-
gdnative-doc-cli
Command line utility for gdnative-doc
-
uciengine
Use chess engine wrapper supporting uci command necessary for playing a game. Analysis is not supported.
-
bevy_terminal_shader
An old school terminal shader for the bevy game engine
-
serde_vrm
Serde types for VRM
-
bevy_fpc_core
Core features for
bevy_fpc -
fishsticks
gamepad input library
-
three
Three.js inspired 3D engine in Rust
-
bevy_anyhow_alert
Easy system error handling with Bevy; let your systems return
Result! -
cuicui_chirp
A file format based on cuicui_dsl to describe bevy UIs
-
keeshond_treats
Easy building blocks for Keeshond so you can start making your games sooner
-
ambient_ui
A UI library for the Ambient runtime, built on top of Ambient's Element library
-
bevy_ecss
Allows using a subset of CSS to interact with Bevy ECS
-
bevy_mod_component_mirror
A bevy plugin to mirror components
-
hill_vacuum_lib
Main HillVacuum library
-
ngen
A very simple game engine using OpenGL
-
romy
A runtime for portable, archivable and deterministic video games
-
space_shared
Subcrate for the space_editor crate. Contains the common types used in the space_editor
-
chargrid_ggez
Graphical chargrid context which renders with ggez
-
adam_fov_rs
Adam Milazzo's FOV algorithm http://www.adammil.net/blog/v125_Roguelike_Vision_Algorithms.html#mine
-
texture_bag
storage and loader for glium textures
-
firewheel-spatial
Spatial audio node for the Firewheel audio engine
-
rattle_items_match
Matching is not limited to character strings. I'm trying to make a game AI.
-
freecell
Game objects and rules for the solitaire card game FreeCell
-
treasury-api
API for treasury server
-
input-actions
An input system for binding PC & Gamepad inputs to application actions
-
bevy_2d_box_physics
A 2D box-collision physics engine for use with the bevy engine
-
landmass_oxidized_navigation
An integration between bevy_landmass and oxidized_navigation for AI navigation
-
tsukurou_engine
Reference Tsukurou! engine implementation
-
bevy_text
text functionality for Bevy Engine
-
grid_pathfinding
Pathfinding using JPS and connected components on a grid
-
bevy_pixel_perfect
Pixel perfect post processing effect for Bevy similar to that in Astortion
-
wasm4fun-fmt
Formatting primitives for WASM-4 fantasy console
-
dialga
Blueprint instantiator for Palkia
-
index_camera_passthrough
Camera passthrough for Valve Index on Linux
-
spritesheet-generator
A spritesheet generator library using the piston's texture_packer
-
micro_quest
Structures and systems for managing game dialog & quests
-
ambient_package_semantic
Semantic analysis for the Ambient package manifests
-
behavior-tree
behavior tree library for rust!
-
gl-headless
Easiest way to create a headless OpenGL context
-
ecs-rs
A super-simple entity-component system in Rust
-
fna3d
Wrapper of FNA3D
-
scone
game engine
-
pg_sdl
A SDL2-superset library for easy game or application development
-
bones3_remesh
Chunk mesh generation functionality for Bones Cubed
-
yuxii
ECS-based 3D game engine
-
grid_plane
Grid plane for the bevy game engine
-
bevy_progress_bar
Easy ninepatch progress bar in bevy
-
legion-task
Fork-join multitasking for Legion ECS
-
bevy_bad_sdr_bloom
Bevy plugin for a bloom-like glow effect that works with WebGL2
-
easel-rs
A shader playground for creating high resolution digital paintings
-
bevylder
Voxels brought to bevy
-
tak
(from the Kingkiller Chronicles)
-
text2rom2600
a companion tool of cc2600 generating rom data for displaying text
-
dfhack-proto
Generated code from the DFHack API
-
ruscii
Terminal graphics engine
-
bones_schema
runtime reflection system designed for scripting
-
moonshine-util
Collection of utilities for Bevy
-
inexor-rgf-model-runtime
Inexor - Reactive Graph Flow - Model - Runtime
-
bevy_xpbd_2d_interp
interpolation of bevy_xpbd rigidbodies
-
bevy_text_animation
text animation library for Bevy
-
bevy_assets_bundler
Assets Bundler for bevy, with content encryption support
-
moonshine-object
Bevy Entities are good. Objects are better!
-
bevy_mod_pies_spacetraders_api
SpaceTraders API implemented for Bevy the game engine
-
omt
A set of tiny tools mostly used for game development. A Texture atlas packer, a font converter, a pakfile creator.
-
ezwin
Easy, minimal Win32 window creation
-
bevy_crt
A package for the bevy engine which enables the use of a CRT effect
-
playdate-controls
High-level controls API built on-top of Playdate API
-
bevy_vach_assets
Bevy Vach Assets is a plugin for Bevy Engine that allows you to load assets from Vach archives
-
okizeme_utils
containing various utility types and functions for okizeme
-
gameboard
creating game board for text UI games
-
fyrox-graph
Graph management crate for the Fyrox engine
-
tetris_gui
Tetris using egui
-
niko
wasm game engine
-
procedural-generation
Procedurally generate maps elegantly
-
bevy_ui_coords
Bevy UI coordinates
-
bevy-either
A Bevy crate allowing macro-built WorldQueries matching over one of many other WorldQueries
-
grid-sim
grid-based simulation in rust
-
overworld_demo_typegame
A typing game demo using the Overworld library
-
myopic-core
Core chess utilities
-
scripthookv-rs
Rust bindings for ScriptHookV
-
shine-store
SHINE. Storage and container module for the shine engine.
-
bevy_python_ffi
run and interact with bevy apps from python
-
bevy_quicsilver
QUIC transport protocol for bevy_ecs, using quinn_proto
-
devotee-backend-softbuffer
Softbuffer-based backend for devotee visualization engine
-
bevy_ui_string_parser
Parser for various values used in bevy-ui
-
VigilantLamp
Multi-target game engine / graphics library
-
bevy_input_mapper
Input binding has never been easier: a Bevy game engine plugin designed with stunning simplicity in mind
-
space_undo
Subcrate for the space_editor crate. Contains undo functionality.
-
seldom_singleton
Helper
SystemParamfor when you have a resource containing a handle -
hom
3D modeling program/viewer
-
aeronet_websocket
WebSocket IO layer implementation for aeronet
-
bevy_ios_alerts
Bevy plugin to request ios native UIAlert popups
-
bevy_crossterm
Develop terminal games with crossterm and Bevy
-
maikklein/unreal-movement
Rust integration for Unreal Engine 5
-
malkmusl-game-engine
Game Engine Supporting OpenGL and Vulkan
-
bevy_mod_check_filter
A module for improved ergonomics with Enabled-style marker components
-
parry3d
3 dimensional collision detection library in Rust
-
bevy_ui_anchor
A small bevy plugin for anchoring UI elements to specific points or entities in the world
-
minecrevy
A toolkit for building Minecraft servers in Rust with Bevy
-
bevy_ecs_ldtk_macros
Derive macros for bevy_ecs_ldtk
-
epicinium_server
An asynchronous multiplayer server for the strategy game Epicinium
-
voxel_engine_types
Public API for the octo voxel game engine
-
check-buddy
The main system of check buddy
-
bevy-inspector-egui-rapier
bevy-inspector-egui integration for rapier
-
wutengine_ecs
The core implementation of the WutEngine ECS
-
bevy_mod_2d_hierarchy
Bevy plugin for more ergonomic 2d
-
bevy_blob_loader
Bevy plugin for loading assets from JavaScript blob URLs
-
podch
Game engine for the podch abstract board game
-
geng-net
Game ENGine
-
bevy_stardust_extras
Miscellaneous utilities for bevy_stardust
-
rantz_cereal
A plugin for Bevy for handling saving and loading
-
morkovmap_rc
A data-driven, Markov Chain-based tilemap generator library and app. Single-thread-flavored.
-
dummy-agones
Dummy Agones SDK server for developing Agones integrations
-
ayaka-plugin
Plugin runtime interface for Ayaka
-
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.
-
simple_engine_2d
A very simple 2D engine
-
bevy_debug_overlay
Bevy plugin to show debug information like fps, frametimes window configuration and more
-
gurgle
dice rolling crate
-
mun
Command-line interface for compiling, monitoring and running Mun code
-
gdunsafe
Macros for godot-rust to hide away some of the common patterns used when working with resources that are shared with the Godot engine
-
recast_navigation
Rust wrappers for recast navigation
-
swamp-render-wgpu
render pixel perfect 2D sprites
-
bevy_dogoap
-
orthrus-panda3d
Orthrus module supporting the Panda3D engine
-
piston-texture
A generic library for textures
-
pulz-ecs
An archetype based ECS
-
bevy_libgdx_atlas
Support loading
libgdx.atlasfiles (used for sprite sheets and such) as Bevy assets -
vdb
A database system implemented in rust that takes ideas from Entity Component Systems and relational databases
-
bevy_wasm_scripting
Adds support for wasm/wat assets in Bevy, and enables easy scripting
-
bevy_prng
providing newtyped RNGs for integration into Bevy
-
astral-error
Error handling library for the Astral Engine (WIP)
-
nimble-participant
Nimble Participant
-
ikarusdef
describing Ikarus' capabilities
-
minecraft-assets
Parsing Minecraft asset files and resource packs in Rust
-
stockton-bsp
parsing Q3 .bsp files
-
bevy_dev
Dev tools for Bevy Engine
-
bracket-algorithm-traits
Traits required for the bracket-* crates. Adapt your maps to the traits with Algorithm2D, Algorithm3D and BaseMap.
-
blue_engine_imgui
ImGUI library for Blue Engine
-
ivy-graphics
high level graphics abstractions like Meshes, Materials, etc. Builds on top of ivy-vulkan
-
bevy_mod_simplest_healthbar
Not really healthbars, but at least it can be used to get some kind of healt indication
-
neos
NeosVR's API in rust
-
node_engine
Node graph engine for Shader graph or Geometry graph
-
bevy_glfw
GLFW window backend for Bevy
-
swamp-wgpu-math
wgpu math types
-
oxygengine-procedural
Procedural content generation module for Oxygengine
-
gdlogue
Game design dialogue creation library
-
silver_animation
A basic animation system for quicksilver
-
bevy_flurx_ipc
way for ipc communication using bevy_flurx
-
ivy-presets
Contains common presets for quickly setting up an application
-
agb_image_converter
converting graphics for use on the Game Boy Advance
-
bevy_mod_scripting_rhai
Necessary functionality for Rhai support with bevy_mod_scripting
-
pagurus_sdl_system
run Pagurus games using SDL 2.0
-
pixel_engine_console
An extension for the pixel_engine game engine that add an in-game console
-
moonshine-check
Validation and recovery solution for Bevy
-
componentile
Kind of like a minimal, tile-based ECS
-
gerg_ui
A little wrapper I've written for creating UI screens from files for the BevyEngine
-
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.
-
bevy_hanabi_loader
A wrapper around bevy_hanabi that lets you define your vfx files in RON format and load them into bevy
-
treasury-server
Treasury server
-
bevy_enum_filter
Filter by enum variant in Bevy queries
-
gsfw-util
game server development utils
-
flappy
version of a game that is definetly not flappy bird using the piston engine
-
gaia_quadtree
A Quadtree implementation for use within Gaia
-
oasis-game-contract
The generic contract for the Oasis Gaming SDK
-
wgpu_tokio
Async bindings using tokio for wgpu
-
rg3d-sound-sdl
Use rg3d-sound with SDL's audio subsystem
-
oni
Later on, there will be a framework for mmo games
-
bevy_defer_picking
bevy_defer reactors for bevy_mod_picking
-
rliron
a roguelike algorithm library
-
xplane
High-level interfaces to the X-Plane plugin SDK
-
luminol-filesystem
Luminol's virtual filesystem
-
png2wasm4src
Convert indexed PNG images to Rust source code for WASM-4 engine
-
perfdata
Parsing and handling performance data for monitoring engines like Nagios, Icinga2,
-
bevy_asset
asset functionality for Bevy Engine
-
maikklein/unreal-api
Rust integration for Unreal Engine 5
-
rekt-protocol-common
Common lib to use the rekt-protocol. See the crate homepage to check the protocol RFC.
-
bevy-animator
An animation library for Bevy that supports many animation formats and animation state machines
-
notation_bevy
Fun notation - bevy features
-
dwat20
emulating dice rolls
-
blend-inspect-rs
parse and analyse Blender's .blend files
-
dip
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
rafx-shader-processor
Rendering framework built on an extensible asset pipeline
-
bevy-overlay-plugin
Bevy plugin to render CEF overlays on top of games
-
distill
Asset framework for game engines & editor suites
-
nimble-ordered-datagram
Nimble Ordered Datagram
-
bevy_streamdeck
Elgato Stream Deck plugin for Bevy
-
keeshond_editor
Editor for the Keeshond Game Engine
-
kit
An small game engine for 3D games
-
bevy_dexterous_developer
A modular hot reload system for rust
-
bevy-tnua-physics-integration-layer
Components for integrating physics backends with bevy-tnua
-
yarnspinner_runtime
Runtime / VM for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
jecs
but functional ECS
-
spades
A popular four person card game implemented in Rust
-
bevy_eventwork
Event based networking library for Bevy
-
bevy_async_system
ability to wait for game status asynchronously
-
rusty_jsc_sys
Raw bindings for the JavaScriptCore engine
-
bevy_device_lang
Crossplatform way to query device language setting
-
xwebtransport
A common WebTransport interface for browser and native. Write once, run anywhere. Originally intended for use with bevy.
-
sheep_cli
Modular and lightweight spritesheet packer
-
ayaka-model
Ayaka high-level runtime
-
roead
Rust port of oead C++ library for common Nintendo formats
-
maikklein/unreal-reflect
Rust integration for Unreal Engine 5
-
bevy_ss_anim
Animated-Sprite From Sprite-Sheets Generated In Adobe Animate
-
ggez-egui
egui for ggez
-
geng-utils
A collection of utilities for Geng engine
-
wutengine_core
Core datatypes and traits for WutEngine
-
hydrate-loader
Game asset pipeline and authoring framework
-
pi_ecs
An excellent ECS framework
-
bevy_shader_mtoon
Bevy MToon shader
-
riichi-decomp
Japanese Riichi Mahjong Waiting Hand Decomposition
-
tanton
A blazingly-fast chess library
-
bevy_roll_safe
Rollback safe utilities and abstractions for Bevy
-
godot-ggrs-wrapper
GDNative project to provide GGRS to the Godot Engine
-
astral-string
String library for the Astral Engine (WIP)
-
reactor_proto
An opinionated rust library for transforming on-disk assets into Entities in Bevy
-
bevy_diagnostic_vertex_count
Bevy diagnostics plugin for counting vertices of all present meshes in a world
-
bevy_fly_camera
A basic flying camera in Bevy
-
swamp-resource
resource container
-
map-parser
parsing and converting maps from vsrg games
-
bevy_xpbd_3d_interp
interpolation of bevy_xpbd rigidbodies
-
newport_engine
Core runnable library for the Newport engine
-
pistoncore-window
window abstraction
-
bones3_core
The core functionality for the Bones Cubed plugin for Bevy
-
swamp-system
Swamp systems
-
resources_package
Macro that allows you to package files inside your libraries or executables
-
bevy_interleave_interface
interface for e2e packed to planar bind groups
-
bevy_retrograde
Pixel-Perfect, 2D Renderer and plugins for Bevy that Seamlessly Targets Desktop and Web
-
extol_pixel_font
Render pixel fonts from PNGs in Bevy
-
fyrox-animation
Flexible Animation System
-
swamp-assets
store assets in a slot map
-
gpm
A package manager for godot
-
bevy_kot_utils
ECS utilities for bevy_kot
-
bevy_stat_bars
plugin for drawing floating stat bars
-
async-uci
An async UCI Implementation over the tokio runtime
-
edger_bevy_util
edger.dev bevy utilities
-
spatialos
System crate used to link with SpatialOs libraries
-
tachyon-networking
a Nack based reliable udp library for games and IPC
-
nate-engine-core
Core Code for a game engine I created just for fun
-
bevy_simple_2d_outline
2D outline materials for the bevy game engine
-
specs_sprite
sprite component for specs
-
bevy_retro_core
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
bosh-rs
A highly customizable physics engine for the game Line Rider
-
overworld_progression
Overworld Progression Library - Experience, Milestone and Level progression
-
prime-derived
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
steel-server
The game server for the steel game engine
-
specs-blit
2D sprite rendering extension for the Specs ECS system
-
otter-daemon
Otter game system; server executable crate
-
bevy_outline
Pixel-Perfect Outline Shader for Bevy
-
fgruc
Fast graphics rendering utility collection // A collection of utils for graphics rendering and game making made with performance in mind
-
libliquidfun-sys
A thin Rust ffi wrapper on top of Box2D and LiquidFun. Built using autocxx.
-
mextk-sys
Bindings to the MexTK library for writing mods for Super Smash Brothers Melee
-
juke
🤖 A small engine for prototyping projects
-
moonshine-tag
Cheap, fast, mostly unique identifiers designed for Bevy
-
tictactoe_menace_s
Tic Tac Toe game with a Menace AI
-
ivy-physics
physics for the Ivy framework
-
egui_extras
Extra functionality and widgets for the egui GUI library
-
bevy_gizmo_log
Render bevy gizmos by logging them
-
aeronet_io
IO abstraction primitives for aeronet
-
sark_pathfinding
astar pathfinding algorthim from red blob games https://www.redblobgames.com/pathfinding/a-star/implementation.html
-
cvars-console-macroquad
In-game console for the macroquad game engine, using the cvars crate for configuration
-
butsuri
Currently only an asset that provides 2d collision detertor and kinematics, build from scratch in bevy
-
snowplay_sys
Low-level bindings to Snowplay, the game engine used in Stormgate, a game by Frost Giant Studios
-
ivy-window
GLFW window wrapper
-
kayak_font
An SDF font renderer for Kayak UI and the Bevy game engine
-
rscenes
Scenes manager for Raylib
-
bevy_event_priority
Bevy plugin providing priority based event handling
-
recast-rs
Bindings for Recast from recastnavigation
-
bevy-firebase-firestore
firebase firestore for the bevy game engine
-
nimble-assent
Authoritative state
-
spectra
Demoscene framework
-
bevy_awesome_debug_camera
customizable drop-in free cam for the (awesome) bevy engine
-
godot-bindings
Internal crate used by godot-rust
-
bevy_despawn_with
Commands extension trait for despawning multiple entities
-
bevy_ui_builder
ui builder library for bevy_ui
-
bevy_mod_gltf_patched
Bevy Engine GLTF loading (patched)
-
shipyard_hierarchy
Hierarchy for Shipyard Entity Component System
-
wgsl-inline
A macro used to embed WGSL within Rust
-
oxygengine-visual-novel
Visual Novel module for Oxygengine
-
kaige_editor
Editor for KaiGE
-
rain2d
2D game engine
-
unity-native-plugin-vulkan
Unity Native Plugin API (Vulkan) for Rust
-
devotee-backend-pixels
Pixels-based backend for devotee project
-
bevy-pixel-map
A pixel based tilemap for bevy!
-
foxtrot
The all-in-one Bevy 3D game template for desktop
-
bevy_remote
The Bevy Remote Protocol
-
beet_ecs
A very flexible AI behavior library for games and robotics
-
bevy_procedural_vegetation
A procedural vegetation system for the Bevy game engine
-
bevy_cameraman
2D camera for bevy
-
bevy_tileset_tiles
Tile definitions used by bevy_tileset
-
arduboy-rust
used in Rust for Arduboy to program Arduboy games in Rust
-
rabex
wip UnityRustExtractor and patcher
-
notan_extra
extra features or plugins for Notan
-
pecs_http
Asynchronous operations for Bevy Engine
-
entity_component
Entity and Component part of a full ECS
-
bevy_quickmenu
way of quickly creating nested menus in bevy that can be navigated with keys, gamepads and pointers
-
nimble-client-logic
Nimble Client Logic
-
qilin
Lightweight Game Engine for making fun 2d Games in Rust
-
bevy_sprite_instancing
A Bevy plugin to render lots of instanced sprites
-
bevy-rrise
A Wwise Bevy integration
-
egui-tetra
egui integration for Tetra
-
bevy_splash_screen
A plugin for bevy which allows you to create screens to show the brands and development teams behind your amazing game
-
omn-sprites
A small library for sprite sheet animation
-
rpgdk
A Roll-Playing Game Development Kit suited for (but not limited to) text adventure games
-
bengine
modern and multi-threaded engine for games and rendering applications. Copyright (c) Bengine Studios - Benjamin Roth. All Rights Reserved.
-
underworld_core
Small library to either play a game or assist in generating rooms
-
dashing
ASCII-style roguelike engine
-
ui4
A reactive vdom-free ui library for the bevy game engine
-
treasury-cli
Command Line Interface for treasury client
-
wgpu-tilemap
wgpu middleware for GPU-accelerated tilemap rendering, primarily targeted at 2d games
-
kudo
A minimalist Entity Component System. (Work in Progress)
-
effect-engine
Effect Engine for building video games
-
wasm4fun-input
Input primitives and subsystems for WASM-4 fantasy console
-
bevy_foliage_paint
A foliage painting system using warbler grass
-
bevy_ui_styled
function that let’s you define a bevy_ui
Stylecomponent withtailwindcssinspired syntax -
bevy_picking_selection
A modular picking plugin for Bevy
-
hexmap
creating and working with hex-based tile maps
-
ira
A general-purpose, code-first game engine
-
fna3d-sys
Rust FFI bindings to FNA3D
-
geng-debug_overlay
Game ENGine
-
maikor-vm-interface
Interface for VM (simulates hardware)
-
unreal_asset
Unreal Engine 4/5 game asset serialization library
-
thunderstore-api
API bindings for the Thunderstore Web API
-
bevy_pixel_buffer
draw pixels in bevy
-
intuicio-framework-ecs
ECS framework module for Intuicio scripting platform
-
noise_rs
The perlin and simplex noise implementation in 2d and 3d
-
magma_api
API of the Magma3D game engine
-
despero-hecs
A fast, minimal, and ergonomic entity-component-system library
-
skillratings
Calculate a player's skill rating using algorithms like Elo, Glicko, Glicko-2, TrueSkill and many more
-
bevy_atomic_save
An atomic save/load system for Bevy Game Engine
-
oxygengine-ha-renderer-debugger
Debugger for Hardware Accelerated renderer module for Oxygengine
-
hana_prefab
Hana prefab is a plugin for bevy that allows you to store level and other data in rooms using prefabs created in code
-
ambient_math
Convenient mathematical operations for the Ambient runtime
-
bevy_retrograde_ldtk
A Bevy Retrograde plugin for reading the LDtk 2D tile map format
-
legion-systems
High performance entity component system (ECS) library
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
pistoncore-winit_window
A winit back-end for pistoncore-window
-
fyroxed
A standalone scene editor for Fyrox game engine
-
shen-nbt5
Just A FASSST NBT parser/writer
-
chessagon
Hexagonal chess
-
bevy_global_input
Global mouse + keyboard input for bevy - doesn't require a focused window
-
bevy_mod_debug_console
Bevy plugin to use console to get information from ECS
-
cyclone2d
A small 2D physics engine from 'Game Physics Engine Development'
-
om-fork-distance-field
Temporary fork! Generate distance fields from images for pseudo-vector rendering
-
crankit-game-loop
A safe and ergonomic entry-point for playdate games using
playdate-sys -
open-oak
2D game engine and rendering library
-
rhusics-ecs
Physics library for use with
specs -
reactor_random
Mostly just a wrapper around fastrand for a bunch of types. Supports bevy and reactor_spatial2d.
-
deathframe
My game development framework for the amethyst game engine
-
ryot_tiled
Supports tile-based game development, providing tools for drawing and managing tilesets and tiled maps
-
shura
A fast cross-plattform 2D component-based game framework
-
ecs
An Entity Component System (ECS) Framework
-
led-rs
A parser for the LEd 2D level editor
-
specs_declaration
macro to effectively create SPECS systems
-
recastnavigation-rs
binding for recastnavigation path finding library adds cross-platform deterministic
-
bevy_regions
A region painting system using a u16 texture
-
ryot_utils
General utilities and helpers for the Ryot framework, supporting a wide range of common game development tasks
-
ambient_sys
A system abstraction for Ambient; abstracts over desktop and web. Host-only.
-
bevy_system_graph
creating strictly ordered execution graphs of systems for the Bevy game engine
-
romy-wasmer
A runtime for portable, archivable and deterministic video games
-
tiles7800
a companion tool of cc7800 generating tiling data from Tiled maps
-
bevy_kot_misc
Miscellaneous prebuilt utilities for bevy_kot
-
bevy_trauma_shake
A plugin for shaking 2d cameras
-
chess-core
A chess engine that stands on its own
-
craydate
A safe Rust API for the Playdate hand held gaming system
-
srs2dge-presets
2D Game Engine
-
nimble-step-map
Nimble Step Map
-
mcvm_net
Various network APIs for MCVM
-
lux-ik
Full Body Inverse Kinematics (FBIK) for games
-
bevy_webview
Rapidly iterate and build Bevy UI's with existing web-based technologies
-
open_ui
🕹 Build cross-platform GUI apps with Rust
-
steel-dynlib
The dynamic library for the steel game engine to reload at runtime
-
rekt_lib
Common lib to use the rekt-protocol. See the crate homepage to check the protocol RFC.
-
game_chess_cui
Command user interface ( CLI ) for chess game implemented for educational purpose
-
bevy_config_cam
An easy plug-n-play multifunctional camera that allows for easy setup of a camera and player for a scene
-
nesbox_utils
Quickly develop NESBox games
-
tm-rs
FFI bindings for the machinery api
-
iyes_scene_tools
Extra helpers for working with Bevy Scenes
-
minorhacks_chess
Fork of the
chesscrate (github.com/jordanbray/chess). This one has a unique set of bugs useful for certain applications; prefer to use the upstream crate. -
bevy_activation
Entity activation manager for Bevy
-
navmesh
NavNet, NavGrid, NavFreeGrid and NavIslands navigation system
-
dfhack-proto-srcs
Download and extract DFHack protobuf files from source
-
riichi-decomp-table
Lookup Table Generation for
riichi-decomp -
mock-agones
Mock Agones SDK server for testing Agones integration
-
planck_ecs_bundle
Adds bundles to planck_ecs
-
optimisticpeach-opengles_graphics
An OpenGL ES 2D back-end for the Piston game engine
-
noframe
Game development framework using crate ggez
-
bevy_event_set
A macro to create event bundles for Bevy
-
island_map_generator_bevy
Island map editor using procedural generation, Rust and Bevy engine
-
hexe
A chess engine
-
yagl
Game Library
-
nimble-host
Nimble Host
-
macroquad-particles
Visual effects editor based on macroquad and megaui
-
bevy_crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding (Bevy version)
-
katharostech/arsenal_runtime
Blender game engine prototype written in Rust
-
screen-selector
A reimplementation of Unity’s ScreenSelector.so plugin, using GTK 4
-
bevy_mops
Mesh Operations library for bevy
-
gilrs-core
Minimal event-based abstraction for working with gamepads
-
aeronet_transport
Transport layer implementation for aeronet
-
minecrevy_io
reading and writing Minecraft protocol types
-
bevy_server_browser
Bevy game engine plugin for creating and searching discoverable servers on local networks
-
bevy_mod_paramap
Parallax mapping shaders (relief and POM) for the bevy game engine
-
playdate-display
High-level Display API built on-top of Playdate API
-
bevy_wonnx
bevy wonnx plugin
-
bevy_quill_obsidian
An opinionated set of editor-focused widgets built on Bevy and Quill
-
rusty_textui
creating simple text user interfaces, like text arcade games in the terminal
-
fly_bevy
Cool utilities for the Bevy game engine
-
bbecs_tutorial
An ECS library made for a tutorial
-
konig
A chess engine built to support variants and custom implementations
-
dip_task
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
bevy_transform
transform functionality for Bevy Engine
-
hydrate-data
Game asset pipeline and authoring framework
-
bevy_mod_fbx
Autodesk Filmbox (*.fbx) loader for Bevy Engine
-
parry3d-f64
3 dimensional collision detection library in Rust. 64-bits precision version.
-
simple_ecs
A super-simple entity-component system in Rust
-
steering
calculations for autonomous agents
-
glyph_packer
packing glyphs into a texture
-
treasury-id
ID generator for treasury
-
akashi
A framework for building collectible card games and gacha games
-
bevy_mod_scripting_rune
Necessary functionality for Rune support with bevy_mod_scripting
-
newport
Modular Game Engine built in Rust
-
bevy-animated-text
Basic animated text plugin for Bevy
-
notan_math
set of math's utils for Notan
-
devcaders
Devcade input support library for Bevy+Rust!
-
oxygengine-animation
Animation module for Oxygengine
-
bevy_4x_camera
A 4X style camera for bevy
-
bevy_api_gen
Code generator tool for bevy
-
bevy_serde_macros
Macros for easing use of serde on bevy entities and components
-
bevy_picking_tilemap
bevy_mod_picking support for bevy_ecs_tilemap
-
swamp-asset-registry
keeps track of asset lifetimes
-
bevy_ios_impact
allows using ios ImpactFeedback API to generate haptic device vibrations
-
rafx-plugins
Rendering framework built on an extensible asset pipeline
-
bevy_starfield
A procedural night sky plugin for bevy
-
turbine_scene3d
Scene rendering for the Turbine engine
-
firewheel-core
Shared types for Firewheel crates
-
pleco_engine
A blazingly-fast Chess AI
-
fyrox-scripts
Standard scripts for the Fyrox engine
-
game_tookit
Experimenting with CG and physics
-
poirebot-lichess
A chess bot for Lichess written in Rust
-
snake-rs
handle the logic for the classic game snake
-
recastnavigation-sys
Raw FFI bindings for recastnavigation
-
bevy_ui_mod_alerts
Easy-spawn UIs that look like little popups
-
nimble-rust
Nimble
-
cuicui_dsl
An easily-extensible macro to spawn things in bevy
-
eframe
egui framework - write GUI apps that compiles to web and/or natively
-
overworld_incremental
Overworld Incremental Library - Tools for incremental games
-
bevy_tmx
Scene loader for .tmx files created by the Tiled map editor
-
bevy_texture_atlas_tools
tools for working with Bevy Texture Atlases
-
blizzard-server
Blizzard Server Engine ❄️ is a solution for a TCP multiplayer server
-
bevy_mesh
mesh types for Bevy Engine
-
expedition
Rich text styling and formatting library
-
carrier-pigeon
networking library for games
-
bevy_generative_grammars
A plugin for handling generative grammars in bevy
-
keeshond_datapack
framework for loading and caching game assets
-
terra-plr
Terraria player parser
-
crabfish
chess engine
-
bevy_kot_ecs
ECS utilities for bevy_kot
-
bevy_tile_atlas
A TextureAtlas builder for ordered tilesets
-
bevy_retrograde_epaint
Epaint integration for rendering in Bevy Retrograde
-
friendly-chess
friendly neighborhood chess engine
-
tictactoe_menace_c
Tic Tac Toe game with a Menace AI
-
bevy-debug-camera
camera plugin perfect for debugging in 3D bevy games
-
bevy_blender_utils
Bevy companion plugin for bevy_blender_utils Blender addon
-
dodgy
ORCA, a local collision avoidance algorithm
-
notan_text
Text API for Notan
-
bevy_flame
bevy flame model viewer plugin
-
cuicui_reflect_query
A bevy reflection addon to query world data from Reflect Components
-
tmx-rs
Loader for Tiled map editor xml files (.tmx)
-
bevy-tnua-xpbd3d
XPBD 3D integration for bevy-tnua
-
bevy_manim
bevy plugin for drawing and animation
-
hedron
An all-in-one 3D modelling library
-
bevy_gizmos
gizmos for Bevy Engine
-
bevy_quill_overlays
Reactive, translucent overlays
-
game_state_machine
A stack-based state machine with update functions
-
atlas
Texture atlas generation (guillotine with dynamic resizing.)
-
bevy_serialization_physics
adding physics wrappers for bevy_serialization_extras
-
bevy_camera_shake
Adds camera shake to your cameras in Bevy Games
-
bevy_kot_ui
UI utilities for bevy_kot
-
bevy_picking_raycast
A modular picking plugin for Bevy
-
alcibiades
A framework for writing chess engines in Rust
-
licoricedev
Lichess API. Development version.
-
thebracket/rltk
A CP437/ASCII terminal library and helpers to make creating roguelike games in Rust easy. Similar to libtcod, but aiming to be Rust-native.
-
bevy_retro_ui
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
bevy_simple_rich_text
A tiny rich text helper for Bevy
-
shipyard_rapier3d
An integration with the physics engine rapier, for the shipard ECS
-
reactor_core
A combined suite of tools provided by reactor for use with the Bevy game engine
-
ugli
Game ENGine
-
swamp-window-runner
winit runner for swamp-app
-
bevy_tray_icon
Allows the use of tray-icon to manipulate the system tray
-
hydrate-base
Game asset pipeline and authoring framework
-
ambient_rustc
Rust compiler driver for the Ambient runtime. Host-only.
-
mewo_ecs
Lightweight ECS
-
dexterous_developer_types
A modular hot reload system for rust
-
bevy-basic-ui
A small manager for menus and huds
-
swamp-basic-input
platform neutral input types
-
kludgine-core
2D rendering for Kludgine
-
bevy_sprite_grid
draws sprites in a grid
-
space_prefab
Subcrate for the space_editor crate. Contains the prefab systems and components.
-
swamp-screen
platform neutral screen and window types
-
helium
A collection of useful functionality for 2D game development
-
bevy_tasks
A task executor for Bevy Engine
-
notation_bevy_utils
Fun notation - bevy utils
-
bevy-add-events-macro
A macro to add multiple events to a bevy app easily
-
swamp-system-runner
Runs swamp systems
-
magma_app
Part of the Magma-API, which is the API of the Magma3D game engine
-
amethyst
Data-oriented game engine written in Rust
-
space_persistence
Subcrate for the space_editor crate. Contains the persistence code for the space_editor
-
tarmac
Resource compiler and asset manager for Roblox projects
-
luminol-result
Luminol's custom error type
-
mun_vfs
in-memory filesystem
-
godot-cell
Internal crate used by godot-rust
-
fna3h
FNA3D types in a hierarchy
-
srs2dge
2D Game Engine
-
bevy_retro_physics
Physics utilities for Bevy Retro
-
minecrevy_text
handling Minecraft text components
-
rluau
High level luau bindings for Rust
-
bevy-tnua-rapier3d
Rapier 3D integration for bevy-tnua
-
bevy_retrograde_ui
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
bevy_sprite_animation
A Node Based Sprite Animatio Plugin, Bassed on Aarthificial's Reanimator
-
terraformer3d
A 3d game engine for quantii
-
shine-stdext
SHINE. General utilities for the general purpose multi-threaded rendering engine.
-
swamp-render
standard render types for 2D
-
calx-ecs
Serializable entity component system for games
-
elaphos
An animation framework for bevy
-
bevy_editor_iris_plugin
Plugin logic for bevy_editor_iris
-
ambient_meshes
Ambient meshes. Host-only.
-
bevy_rhai
An easy way to integrate Rhai with Bevy
-
puffin_egui
Show puffin profiler flamegraph in-game using egui
-
bevy_state_stack
An improved state stack for bevy
-
firewheel-graph
Core audio graph algorithm and executor for Firewheel
-
ayaka-script
First-class script language in Ayaka
-
flatbox_ecs
ECS functionality for Flatbox engine
-
wasm4fun-logo
Logo animation for WASM-4 fantasy console
-
bones_asset
Asset interface for bones_lib
-
bevy_ios_review
Bevy plugin for to request ios native review API from within the App
-
luminol-audio
Luminol's audio backend
-
bevy_kindly
Minimalistic implementation of entity kinds for Bevy ECS
-
winit-input-map
Input Map for Winit with gamepad support
-
bevy_proto_typetag
bevy_proto with typetag support
-
intuicio-plugins
Plugins module for Intuicio scripting platform
-
ayaka-bindings
WASM bindings of plugins written for Ayaka
-
swamp-log
Initializes logging
-
rusty-chess-core
Core functionalities of the chess engine
-
bevy-compose
Reactive UI framework for Bevy
-
ryot
MMORPG library based on the concepts of open tibia written in rust and bevy
-
bevy_log
logging for Bevy Engine
-
starry-ecs
A crude ECS system
-
overworld_resource
Overworld Resource Library - Resource management
-
godot_rust_helper
CLI tool to help you create and update Rust modules for your Godot projects
-
bevy_simple_stat_bars
draw stat bars that follow sprites
-
quilkin-macros
Quilkin is a non-transparent UDP proxy specifically designed for use with large scale multiplayer dedicated game server deployments, to ensure security, access control, telemetry data, metrics and more
-
space-render
A compact render plugin to the Amethyst game engine which renders background stars, close up stars (the sun) and planet atmospheres using atmospheric scattering
-
sprocket_engine
A vulkan game engine
-
otter-support
Otter game system; support code Rust crate
-
mun_runtime_capi
C API for the Mun runtime
-
photon_decode
Set of utilities for decoding messages generated by photon framework
-
reactor_camera
A 2D camera plugin for Bevy, inspired by the Love2D camera plugin - STALKER-X
-
guimcaballero/bevy_chess
Chess demo in Bevy
-
bevy-embasset
A Bevy plugin to embed assets in your game, or load assets from other sources!
-
vleue_kinetoscope
Animated GIF player for Bevy
-
lueur
Shadowy game and graphics library for Rust
-
bevy_rapid_qoi
Bevy support for the QOI (Quite OK Image) format, based on rapid_qoi
-
nimble-rectify
Integration between assent and seer
-
wolf_engine_framework
A complete, "batteries-included" framework for Wolf Engine
-
steel-client
The game client for the steel game engine
-
storylets
Embeddable storylet-based narrative engine for games
-
astral-math
Math library for the Astral Engine (WIP)
-
conditional_commands
Bevy Commands extension
-
aeronet_replicon
aeronet backend implementation for bevy_replicon
-
micro_bevy_splash
one-shot logo splash screen for Bevy
-
md-mage
Matt's ASCII Game Engine
-
crankit-image
An ergonomic image API for the playdate
-
swamp-assets-loader
loads assets
-
bevy_prototype_inline_assets
Bevy plugin for loading assets that are bundled into the binary
-
ambient_project
Definition of the Ambient project manifest format
-
oxygen_orbit
Oxygen Orbit is an API library (for Perlin Noise and more) mainly developed for the Oxygen Game Engine
-
bevy_stokes
A bevy plugin providing a thin and ergonomic wrapper around laminar
-
pantheon
An opinionated WIP/Experimental 3D game engine
-
blunders-engine
UCI chess engine core
-
recs
flexible, macro-free entity-component system in pure (stable!) Rust
-
swamp-loader
Loads assets for swamp
-
godot-ffi
Internal crate used by godot-rust
-
bones_matchmaker
matchmaking server for games
-
bevy-tnua-xpbd2d
XPBD 2D integration for bevy-tnua
-
nuuro_build
A specialized 2D game library
-
ivy-input
Input handling crate for Ivy
-
smecs
Dependency free ECS
-
mun_memory
Memory management functionality for Mun
-
bevy_mod_ui_texture_atlas_image
Draw images from texture atlases with the Bevy UI
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
headless_webview_engine
Headless Webview implementation for Linux - WIP
-
vleue_sentry
Sentry reporting plugin for Bevy
-
crankit-sys
Generated bindings for the playdate C API
-
gamesense
SteelSeries GameSense™ client written in Rust
-
bevy_picking_input
A modular picking plugin for Bevy
-
cuicui_layout
A layout algorithm for bevy and made to be understood by humans
-
swamp-boot
Collection of plugins to boot a swamp-app
-
flatbox
Rust ECS game engine with editor written in C#
-
yarnspinner_core
Core concepts for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
moon_script
Fast and simple scripting language based on Rust
-
bevy_other_world
Experimental subworlds plugin for Bevy
-
oxygengine-integration-vn-ui
Integration module of visual novel and user interface for Oxygengine
-
bevy_retrograde_physics
Physics utilities for Bevy Retrograde
-
snowplay
Idiomatic Rust interface to Snowplay, the game engine used in Stormgate, a game by Frost Giant Studios
-
bevy_ui_animation
A GSAP-like animation plugin for Bevy UI
-
dragon
3D/2D game engines implemented with ECS concepts
-
procedural_modelling
A framework-agnostic Procedural Modelling crate
-
rscenes-raylib-connector
Raylib connector for Rscenes 2
-
bevy_assetio_zip_bundler
An asset bundler for the bevy_assetio_zip crate
-
swamp-slot-map
minimal slot map using index and generation
-
bevy_picking_highlight
A modular picking plugin for Bevy
-
rose-graph
a small graph, not usable for most projects
-
ecs-lib-rs
An Entity Component System (ECS) Framework for learning
-
bevy-pigeon
The bevy plugin for carrier-pigeon
-
regigigas
Registration system for game objects
-
appl
physics engine powered by the Rapier library. It is currently 2d only.
-
notan_core
Basic types and structs used in Notan
-
playdate-menu
High-level system menu API built on-top of Playdate API
-
swamp-system-state
Keeps the state that is provided to systems
-
egui_glium
Bindings for using egui natively using the glium library
-
simbelmyne-chess
A chess library that takes care of board representation and move generation, used by the Simbelmyne chess engine
-
playdate-rs
Safe Rust bindings for the Playdate SDK C-CPI
-
newport_cache
Cache Builder for Newport
-
replace_ident_in_expr
Replaces target ident with given ident in an expr
-
newport_asset
Thread safe asset manager for Newport engine
-
bevy_ninepatch
Displays 9-Patch UI elements in Bevy
-
tictactoe_menace_player
Tic Tac Toe game with a Menace AI
-
pistoncore-input
A structure for user input
-
beetmash_template
An example workflow for publishing Bevy apps and scenes to Beetmash
-
shine-testutils
SHINE. Unit test helpers for the shine engine.
-
ambient_ecs
Ambient ECS. Host-only.
-
pistoncore-event
flexible generic event threading
-
rusty-editor
A scene editor for rg3d game engine
-
enteum
Lightweight Entity Component System with Rust
-
bevy_chair
Chair mesh asset loader plugin
-
bevy_sprite_material
Plugin to use materials for sprites
-
shipyard_rapier2d
An integration with the physics engine rapier, for the shipard ECS
-
nimble-sample-step
Nimble Sample Step Type
-
bevy_prank
Opinionated Unreal Engine inspired spectator camera for the Bevy game engine
-
gdnative-sys
Generated bindings to the Godot game engine's gdnative core types (See the gdnative crate)
-
swamp-wgpu
wgpu utility functions
-
mass
3D physics engine
-
bevy-orbit-controls
An orbit controls plugin for bevy
-
rsanim
A basic state machine for managing sprite animations
-
bevy_aoui
A light-weight anchor-offset based 2D sprite layout system for the bevy engine
-
wasm4fun-storage
Storage primitives and subsystems for WASM-4 fantasy console
-
bevy_sprite
sprite functionality for Bevy Engine
-
geng-ecs
Game Engine (ecs)
-
oxygengine-overworld
RPG overworld module for Oxygengine
-
cargo-geng
Game ENGine
-
treasury-store
Treasury storage
-
bones_utils
Utilites used throughout the bones_framework
-
tanton_engine
A blazingly-fast Chess AI
-
minimum
A collection of utilites for games
-
parry2d-f64
2 dimensional collision detection library in Rust. 64-bit precision version.
-
bracket-embedding
resource embedding services for bracket-lib
-
bevy_retrograde_audio
Bevy plugin for playing sounds
-
dotrix_sky
Sky for Dotrix 3D Game Engine
-
siege
Render pixel art siege engines
-
bevy_oneshot
ohe-shot systems for Bevy
-
mod_plugins_macros
Reduce plugin boilerplate in the Bevy game engine
-
rekt-common
Common lib to use the rekt-protocol. See the crate homepage to check the protocol RFC.
-
dexterous_developer_test_utils
A modular hot reload system for rust
-
aether_spyglass
A general-purpose extensible inspector for bevy engine
-
godot-codegen
Internal crate used by godot-rust
-
rox2d
2D physics engine heaviliy inspired by (the venerable) Box2D physics engine
-
async-ecs
Async Parallel Entity Component System for Rust
-
rift_insight
A third party API library for League of Legends
-
bevy_hsl_multiplier
Multiply texture values in HSL color space
-
naia-shared
Common functionality shared between naia-server & naia-client crates
-
dotrix_overlay
Overlay for Dotrix 3D Game Engine
-
nimble-layer
Nimble Layer
-
srs2dge-gizmos
2D Game Engine
-
rapier2d
2-dimensional physics engine in Rust
-
akinator-rs
wrapper around the undocumented Akinator API
-
bevy_kot
Koe's Bevy toolkit
-
rialight
module
-
prints
Template entity blueprints for bevy
-
oxygengine-navigation
Navigation module for Oxygengine
-
bevy_concurrent_event
concurrent event plugin,the principle is similar to Commads,events can be send/read concurrently, but the reading of events is always in the next bevy frame
-
cgmath_dolly
Composable camera rigs but this time using CGMATH
-
oxygengine-input-device-web
Web input devices module for Oxygengine
-
bevy_xml
An Sparrow SpriteSheet XML Parser for Bevy!
-
bevy-undo2
makes it easy to use the undo-operation on bevy
-
entity_store_code_gen
Code generator for game data store
-
bevy_action_animation
Action-based animation system
-
librollenspielsache
API for working with tabletop RPG entities
-
mun_compiler
Binary compilation functionality for Mun
-
ryot_sprites
Focuses on sprite management, handling animations and graphical representations for dynamic visual content in games
-
swamp-font
Font asset loading
-
bevy_mod_ui_sprite
Draw sprites with the Bevy UI
-
steel-proc
The steel game engine proc-macro library
-
bevy_follow_path
components and systems that enable entities to follow a path
-
bevy_asset_packer
Easy to use bevy plugin for packing resources in single file and protect him
-
bevy_keybind
Common event interface for bevy_input, so that we can better separate logic from configuration
-
luminol-config
Luminol's configuration
-
bevy_backroll
A Bevy engine integration plugin for the backroll rollback networking library
-
terminity
Enviroment for the best terminal UI quality for games
-
ayaka-plugin-wasmi
A plugin runtime for Ayaka, based on Wasmi
-
bevy_retro_camera
Scaled pixel-perfect rendering camera for Bevy
-
flatbox_assets
assets management functionality for Flatbox engine
-
yaecs
Entity Component System
-
transform-gizmo
3D transformation gizmo
-
swamp
2D Game Engine
-
firefly-rust
Rust SDK for making Firefly Zero games
-
bevy_yarnspinner_demo
A demo for Bevy Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
bevy_scene
scene functionality for Bevy Engine
-
bevy_bones3
A voxel world storage and mesh generation plugin for Bevy
-
bevy_mod_scripting_common
Traits and syn structures for language implementors
-
swamp-loader-plugin
Plugin for swamp-loader
-
hydrate-model
Game asset pipeline and authoring framework
-
nate-engine-macros
Macros for a game engine I created just for fun
-
bevy_window
windowing functionality for Bevy Engine
-
yarnspinner_codegen
Code generation for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
rg3d-physics
Physics library for rg3d-engine
-
component_table
Data structure for associating data with entities in an Entity Component System
-
bevy_renet
Bevy plugin for the renet crate: Server/Client network library for multiplayer games with authentication and connection management
-
swamp-boot-game
Plugin to boot a swamp-game
-
crankit-input
An ergonomic input API for the playdate
-
flatbox_systems
ECS systems for Flatbox engine
-
include-wgsl-oil
Includes a WGSL file with the
naga-oilpreprocessor -
treasury-client
Client for treasury
-
nimble-sample-game
Nimble Sample Game Types
-
overworld_affinity
Overworld Affinity Library - Affinity and Multipliers
-
beet
A very flexible AI behavior library for games and robotics
-
bevy_image
image types for Bevy Engine
-
siege-editor
Pixel art siege engine editor/animator/creator
-
playdate-color
Color extension for Playdate API
-
usfx
Realtime procedurally generated sound effects
-
bevy-tnua-rapier2d
Rapier 2D integration for bevy-tnua
-
steel-project
The steel game engine template project
-
covey_asset_loader
Bevy plugin for asset loading
-
bevy_tileset_core
Core of bevy_tileset
-
codegame
framework
-
oil
User interface library oriented for games. It includes user interface languages.
-
swamp-asset-reader
reads assets async on multiple platforms
-
egui-tetra2
egui integration for Tetra
-
matchbox_signaling
Painless WebRTC peer-to-peer signaling servers
-
psyche-amethyst
Amethyst game engine integration for Psyche AI Toolset
-
steel-editor
The editor for the steel game engine
-
nuuro
A specialized 2D game library
-
tw4f
A tiny and safe abstraction over the WASM-4 fantasy console
-
hydrate-codegen
Game asset pipeline and authoring framework
-
geng-draw2d
Game ENGine
-
wasm4fun-time
Time primitives and subsystems for WASM-4 fantasy console
-
ryot-assets-cli
CLI for managing assets from the Tibia client for Ryot
-
edict-proc
Powerful entity-component-system library
-
tarator
game engine wie an ECS and a UI
-
reactor_serial
A plugin for Bevy for handling saving and loading
-
egui-winit
Bindings for using egui with winit
-
bones_scripting
Official scripting integration with bones_framework
-
bevy_hierarchy
hierarchy functionality for Bevy Engine
-
hydrate-pipeline
Game asset pipeline and authoring framework
-
bevy_wasm_touch_fix
For Bevy >=0.12, a plugin that fixes the issues of incorrect touch positions in wasm
-
bevy_picking_ui
A modular picking plugin for Bevy
-
rafx-nodes
Rendering framework built on an extensible asset pipeline
-
ecs_game_in_rust
Entity Compnent System map for games (a simple test for rust programming)
-
bevy_rectray_picking
bevy_mod_picking backend for bevy_rectray
-
fyrox-core
Shared core for the Fyrox engine and its external crates
-
bevy-trait-query-impl-0-14-0
Procedural macro for
bevy-trait-query -
vngineer
Visual Novel game engine
-
lux
A super simple 2d-graphics engine that handles windowing and events for you! Right now it's supposed to be a top secret! Shhhhh
-
pecs_core
Asynchronous operations for Bevy Engine
-
swamp-asset-image
image asset loading
-
bevy_flurx_wry_core
The core crate of bevy_flurx_wry
-
ggez_ui
ui for ggez. No tutorial yet, but i might make one later
-
playdate-scoreboards
High-level Scoreboards API built on-top of Playdate API
-
aeronet_channel
In-memory MPSC channel IO layer implementation for aeronet
-
oxygengine-audio-backend-web
Audio Web backend module for Oxygengine
-
swamp-game-wgpu
swamp game implementation using wgpu
-
bevy_asset_manager
asset loading and organization in bevy
-
bevy_image_config
Bevy plugin that automatically configures image assets when they load
-
bevy_tiled_blueprints
Allows reading tiled maps with properties
-
space_bevy_xpbd_plugin
Space XPBD plugin for space_editor crate
-
ayaka-bindings-types
Types both used in Ayaka runtime and Ayaka plugins
-
bevy_pathmesh
Navmesh plugin for Bevy
-
dexterous_developer_cli
A CLI for hot reloadable Rust applications, using the dexterous_developer crate
-
rafx-resources
Rendering framework built on an extensible asset pipeline
-
srs2dge-ecs
2D Game Engine
-
zengine_asset
asset functionality for ZENgine
-
nanquim
3d game framework
-
flecs-sys
low-level bindings to the Entity Component System (ECS) framework flecs
-
tm-derive
FFI bindings for the machinery api
-
dexterous_developer_manager
A modular hot reload system for rust
-
beet_flow
A very flexible AI behavior library for games and robotics
-
bevy_editor_pls_core
In-App editor tools for bevy apps
-
mun_test
Functionality for testing Mun code
-
ambient_animation
Ambient animation functionality. Host-only.
-
luminol-macros
Various utility macros used by Luminol
-
bracket-rex
Load/save REX Paint files and utilize them in bracket-terminal projects
-
bevy_color
Types for representing and manipulating color values
-
oxygengine-network-backend-desktop
Network Desktop backend module for Oxygengine
-
bevy_flurx_wry_api
api plugins for bevy_flurx_wry
-
goshawk
An RTS camera for bevy
-
ayaka-plugin-wasmtime
A plugin runtime for Ayaka, based on Wasmtime
-
piston-shaders
Shaders for game development in Rust
-
newport_log
Global logger package for Newport engine
-
firewheel-cpal
cpal backend for Firewheel
-
bevy_flurx_ipc_macro
provide ipc-command macro for bevy_flurx_ipc
-
geng-camera
Game ENGine
-
bones_bevy_renderer
Bevy rendering implementation for the bones_framework
-
swamp-asset-id
ownership asset ids
-
bevy_retrograde_core
The core components and renderer of Bevy Retrograde
-
oxygengine-build-tools
Build tools for Oxygengine
-
dotrix_math
Math crate for Dotrix 3D Game Engine
-
godot-core
Internal crate used by godot-rust
-
fyrox-dylib
Dynamic library for Fyrox Game Engine
-
fyrox-impl
Feature-rich, easy-to-use, 2D/3D game engine with a scene editor. Like Godot, but in Rust.
-
amethyst-navigation
Navigation module for Amethyst Engine
-
rapier_testbed2d
Testbed for the Rapier 2-dimensional physics engine in Rust
-
zero_ecs_macros
Procedural macros for Build scripts for: ZeroECS: an Entity Component System (ECS), using only zero-cost abstractions
-
bevy-atlas-loader
Bevy plugin for defining and loading 2D TextureAtlas images
-
uil
User interface library oriented for games. It includes user interface languages.
-
srs2dge-link-static
2D Game Engine
-
wasm4fun-random
Random number generators primitives and subsystems for WASM-4 fantasy console
-
gdnative-core
The Godot game engine's gdnative core bindings
-
ivy-base
Base crate for the Ivy game engine
-
constellation
A data-oriented entity component system optimized for cache coherent resource access and parallel system execution
-
transform-gizmo-egui
egui integration for transform-gizmo
-
lightyear_macros
Procedural macros for the lightyear networking library
-
dotrix_ecs
Entity Component System implementation for Dotrix game engine
-
mun_skeptic
ability to test Mun code snippets in an mdbook
-
ambient_physics
Ambient physics. Host-only.
-
bevy_time
time functionality for Bevy Engine
-
oxygengine-network-backend-native
Network Native backend module for Oxygengine
-
mun_runtime
A runtime for hot reloading and invoking Mun from Rust
-
bevy_picking_rapier
A modular picking plugin for Bevy
-
hydrate-schema
Game asset pipeline and authoring framework
-
commands_send_event
Bevy generic event dispatcher extension trait
-
overworld_components
adding game systems useful for incremental and management games
-
goods-treasury
Database for "goods" asset pipeline
-
dexterous_developer_builder
A modular hot reload system for rust
-
goods-treasury-import
"Treasury" API for importers
-
bevy_quill_obsidian_inspect
A reflective property inspector widget built on Bevy, Quill and Quill/Obsidian
-
mun_language_server
language server protocol server for the Mun language
-
mun_project
convenience structures for Mun projects
-
bevy_fixed_sprites
Bevy sprites that don't rotate or scale with their transform
-
oxygengine-integration-ow-ha
Integration module of RPG overworld and Hardware Accelerated rendering for Oxygengine
-
ambient_app
Ambient app implementation. Host-only.
-
modulator
A trait for abstracted, decoupled modulation sources
-
rapier3d
3-dimensional physics engine in Rust
-
sdl3
Cross-platform multimedia
-
oxygengine-integration-ui-ha
Integration module of user interface and Hardware Accelerated rendering for Oxygengine
-
crankit-time
An ergonomic time API for the playdate
-
flat_commands
bevy ecs extension traits
-
luminol-term
Luminol's in-built terminal
-
moonshine-core
Unconventional framework for making games in Bevy
-
oxygengine-ignite
CLI app used to setup and develop Oxygengine projects
-
bevy_core_pipeline
core render pipeline for Bevy Engine
-
beet_examples
A very flexible AI behavior library for games and robotics
-
bevy_mod_scripting_core
Core traits and structures required for other parts of bevy_mod_scripting
-
geng-shader
Game ENGine
-
bones_framework
The Bones game development framework
-
ambient_gizmos
Ambient gizmos. Host-only.
-
newport_editor
Editor for Newport engine
-
bevy_picking_avian
A modular picking plugin for Bevy
-
rapier3d-urdf
URDF file loader for the 3D rapier physics engine
-
bevy_ptr
working with untyped pointers in a more safe way
-
bevy_mod_sysfail_macros
Macros for bevy_mod_sysfail
-
wasm4fun
Primitives and constants from WASM-4 fantasy console
-
oxygengine-editor-tools
Editor tools for Oxygengine
-
bevy_picking_sprite
A modular picking plugin for Bevy
-
piston2d-glow_wrap
Glow wrapping code for Piston OpenGL backend
-
bevy_extern_events
Bevy plugin for generic external events to be send to bevy EventReaders
-
piston-dyon_interactive
interactive coding with the Piston game engine
-
intuicio-backend-rust
Rust backend module for Intuicio scripting platform
-
space_editor_ui
Subcrate for the space_editor crate. Contains the UI for the editor.
-
hydrate-editor
Game asset pipeline and authoring framework
-
bundle_bundle
bundle bundles in a chain
-
nimble-wrapped-step
Nimble Wrapped Steps
-
lunex_engine
not inteded to be used standalone. It is a dependency of Bevy_Lunex
-
ambient_network
Ambient networking functionality. Host-only.
-
bevy_quill_obsidian_graph
A collection of widgets for implementing node-graph editors
-
bevy_mikktspace
Mikkelsen tangent space algorithm
-
bevy_picking_xpbd
A modular picking plugin for Bevy
-
nimble-ffi
Nimble FFI
-
heron
An ergonomic physics API for 2d and 3d bevy games. (powered by rapier)
-
ambient_cb
Defines helper types for callbacks wrapped in
Arcthat implementDebug -
aeronet_webtransport
WebTransport IO layer implementation for aeronet
-
bevy_aoui_widgets
UI, events and dsl for the bevy_aoui crate
-
geng-audio
Game ENGine
-
srs2dge-link-dynamic
2D Game Engine
-
bevy_gltf
Bevy Engine GLTF loading
-
moshimoshi
A small crate to sugar working with command callbacks in bevy
-
bevy_windows_param
Bevy
SystemParamproviding a more ergonomic interface for accessing window-specific information, like resolutions and cursor positions -
wasm4fun-panichandler
Panic handler for WASM-4 fantasy console
-
bevy_log_diagnostic
Logs diagnostic informations from Bevy
-
dexterous_developer_dylib_runner
A modular hot reload system for rust
-
rapier3d-f64
3-dimensional physics engine in Rust
-
beet_core
A very flexible AI behavior library for games and robotics
-
goods-treasury-import-ffi
"Treasury" API for importers
-
swamp-game
common swamp game types
-
oxygengine-physics-2d
2D physics module for Oxygengine
-
ayaka-plugin-nop
A dummy plugin runtime for Ayaka
-
newport_imgui
Immediate Mode GUI for Newport
-
cuicui_layout_bevy_sprite
Integration with bevy_sprite for cuicui_layout
-
bevy_touch_stick
Bevy virtual touch joystick for mobile games
-
bevy_animation
animation functionality for Bevy Engine
-
bevy_octopus_websocket
ECS based networking library for Bevy
-
bevy_ldtk
A Bevy plugin for reading the LDtk 2D tile map format
-
turbine
A 3D game engine with built-in editor
-
bevy_winit
A winit window and input backend for Bevy Engine
-
bevy_diagnostic
diagnostic functionality for Bevy Engine
-
ambient_text
Ambient text. Host-only.
-
geng-asset
Game ENGine
-
bevy_utils
A collection of utils for Bevy Engine
-
bevy_independent_transform
Entities with an IndependentTransform have a position relative to their parent, but aren't part of the Bevy Transform hierarchy
-
mun_libloader
Functionality for loading Mun libraries
-
bevy_lunex
Blazingly fast path based retained layout engine for Bevy entities, built around vanilla Bevy ECS
-
bevy_picking_egui
A modular picking plugin for Bevy
-
bevy_mod_scripting_rhai_derive
Necessary functionality for Rhai support with bevy_mod_scripting
-
bones_render
Core rendering types for bones_lib
-
wasm4fun-log
Logging functions and macros for WASM-4 fantasy console
-
bevy_ui_material
Plugin to use materials for UI
-
dynamo
dynamically typed scripting language
-
bevy_audio
audio functionality for Bevy Engine
-
rapier3d-meshloader
STL file loader for the 3D rapier physics engine
-
rg3d-core
Shared core for the rg3d engine and its external crates
-
beetmash_scene
The number one bevy scene registry
-
aeronet_wt_core
Core types for the WebTransport implementations for aeronet
-
oxygengine-utils
module for Oxygengine
-
oxygengine-user-interface
User Interface module for Oxygengine
-
mun_compiler_daemon
Functionality for continuously monitoring Mun source files for changes and triggering recompilation
-
bevy_ui_3d
A UI plugin to enable 3d interactions
-
newport_ecs
Custom ECS made for Newport
-
bevy_gilrs
Gamepad system made using Gilrs for Bevy Engine
-
bevy_ui_style_builder
Experimental Bevy UI helper extension methods
-
cuicui_layout_bevy_ui
Integration with bevy_ui for cuicui_layout
-
ambient_decals
Ambient decals. Host-only.
-
oxygengine-prototype
Prototyping utilities module for Oxygengine
-
bevy_reflect
Dynamically interact with rust types
-
oxygengine-ha-renderer
Hardware Accelerated renderer module for Oxygengine
-
bones_bevy_utils
using Bones with Bevy
-
oxygengine-ai
AI module for Oxygengine