-
bevy
A refreshingly simple data-driven game engine and app framework
-
glam
fast 3D math library for games and graphics
-
bevy-inspector-egui
Inspector plugin for the bevy game engine
-
bevy_egui
A plugin for Egui integration into Bevy
-
gilrs
Game Input Library for Rust
-
leafwing-input-manager
A powerful, flexible and ergonomic way to manage action-input keybindings for the Bevy game engine
-
bevy_asset_loader
Bevy plugin for asset loading
-
bevy_ecs_tilemap
A tilemap rendering plugin for bevy which is more ECS friendly by having an entity per tile
-
raylib
Safe Rust bindings for Raylib
-
bevy_tweening
Tweening animation plugin for the Bevy game engine
-
shakmaty
Chess and chess variant rules and operations
-
tiled
loading maps created by the Tiled editor
-
sdl3
Cross-platform multimedia
-
jomini
Low level, performance oriented parser for save and game files from EU4, CK3, HOI4, Vic3, Imperator, and other PDS titles
-
avian2d
An ECS-driven physics engine for the Bevy game engine
-
bevy_easings
Easing plugin for Bevy
-
hexx
Hexagonal utilities
-
bevy_ecs_tiled
A Bevy plugin for loading Tiled maps
-
bevy_hanabi
Hanabi GPU particle system for the Bevy game engine
-
bevy_framepace
Frame pacing and frame limiting for Bevy
-
bevy_mod_debugdump
Visualization tools for bevy
-
bevy_flowfield_tiles_plugin
FlowField (vector field) pathfinding as a plugin to the Bevy game engine
-
bevy_rapier2d
2-dimensional physics engine in Rust, official Bevy plugin
-
bevy_panorbit_camera
A basic pan and orbit camera in Bevy
-
bevy_ecs
Bevy Engine's entity component system
-
screen-13
Vulkan rendering engine in the spirit of QBasic
-
tiger-lib
used by the tools ck3-tiger, vic3-tiger, and imperator-tiger. This library holds the bulk of the code for them. It can be built either for ck3-tiger with the feature ck3, or for vic3-tiger with the feature vic3…
-
bevy_defer
asynchronous runtime for executing async coroutines
-
bevy_replicon
A server-authoritative replication crate for Bevy
-
bevy_polyline
Polyline Rendering for Bevy
-
cc7800
a subset of C compiler for Atari 7800
-
line_drawing
A collection of line-drawing algorithms for use in graphics and video games
-
bevy_rand
A plugin to integrate rand for ECS optimised RNG for the Bevy game engine
-
bevy-tnua
A floating character controller for Bevy
-
godot
Rust bindings for Godot 4
-
bevy_spritesheet_animation
A Bevy plugin for animating sprites
-
bevy_lunex
Blazingly fast retained UI layout engine for Bevy ECS
-
lightyear
Server-client networking library for the Bevy game engine with modular architecture
-
transvoxel
Eric Lengyel's Transvoxel Algorithm
-
bevy-persistent
A Bevy helper to easily manage resources that need to persist across game sessions
-
foxtrot
A 3D reference project and tech demo for the Bevy Engine
-
dyon
dynamically typed scripting language
-
macaw
An opinionated game math library built on top the excellent glam
-
cardpack
Generic Deck of Cards
-
bevy_voxel_world
A voxel world plugin for Bevy
-
bevy_tween
Flexible tweening plugin library for Bevy
-
bevy_transform_interpolation
Transform interpolation for fixed timesteps for the Bevy game engine
-
bevy_simple_subsecond_system
Hotpatch your Bevy systems, allowing you to change their code while the app is running and directly seeing the results!
-
bevy_infinite_grid
A 3D infinite grid for Bevy
-
edict
Powerful entity-component-system library
-
bevy_mod_physx
PhysX plugin for Bevy
-
caith
A dice roller library supporting many features
-
game-loop
that implements a frame-rate-independent game loop
-
mc-repack
A command-line interface for repacking Minecraft mods and resource packs to optimize size and loading speed
-
dolly
Composable camera rigs
-
bevy-sequential-actions
A Bevy library for executing various actions in a sequence
-
iyes_perf_ui
Customizable Performance/Debug Overlay for Bevy UI
-
sfml
Rust binding for sfml
-
asphalt
Upload and reference Roblox assets in code
-
moonshine-save
Save/Load framework for Bevy
-
rustcycles
A fast multiplayer shooter on wheels in Fyrox
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
flecs_ecs
Rust API for the C/CPP flecs ECS library https://github.com/SanderMertens/flecs
-
azalea
A framework for creating Minecraft bots
-
csgrs
Constructive solid geometry (CSG) on meshes using BSP trees in Rust
-
bevy_pancam
A camera that allows panning by dragging with the mouse
-
timecat
NNUE-based chess engine that implements the Negamax algorithm and can be integrated into any project as a library. It features move generation, advanced position evaluation through NNUE, and move searching capabilities.
-
bevy_sprite3d
Bevy Plugin to allow using 2d sprites in a 3d scene
-
bevy_save
A framework for saving and loading application state in Bevy
-
bevy_flurx
Allows you to use coroutine in Bevy
-
shipyard
Entity Component System
-
seldom_state
Component-based state machine plugin for Bevy. Useful for AI, player state, and other entities that occupy various states.
-
bevy-input-sequence
Recognizes and acts on input sequences
-
bevy_atmosphere
A procedural sky plugin for bevy
-
ggez
A lightweight game framework for making 2D games with minimum friction, inspired by Love2D
-
bevy_scriptum
Plugin for Bevy engine that allows you to write some of your game or application logic in a scripting language
-
bevy_materialize
Load, store, and apply type-erased materials in Bevy
-
bevy-tokio-tasks
integration of a Tokio runtime into a Bevy app for background processing
-
bevy_svg
Load and draw SVG files in Bevy
-
bevy_trenchbroom
TrenchBroom and ericw-tools integration with Bevy
-
bevy_ratatui_camera
A bevy plugin for rendering your bevy app to the terminal using ratatui
-
hill_vacuum
A bevy-based 2D map editor
-
bevy_ldtk_asset
A Bevy plugin to support LDtk files as assets!
-
bevy_cobweb_ui
UI framework for the bevy game engine
-
bevy_enhanced_input
Input manager for Bevy, inspired by Unreal Engine Enhanced Input
-
bevy_mod_outline
A mesh outlining plugin for Bevy
-
bevy_slippy_tiles
slippy tile fetching functionality in the Bevy game engine
-
cfr
Counterfactual regret minimization solver for two-player zero-sum incomplete-information games
-
bevy_async_task
Ergonomic abstractions to async programming in Bevy
-
vector2d
The spoon of 2D vector libraries, intended for simple game development
-
bevy_debug_grid
A bevy plugin for creating grids, for debugging purposes
-
bevy_ios_iap
Bevy Plugin and Swift Package to provide access to iOS native StoreKit2 from inside Bevy Apps
-
bevy_trackball
Coherent virtual trackball controller/camera plugin for Bevy
-
kill-them-all
A 'Path Of Exile' super lite 2D game
-
bevy_quinnet
Bevy plugin for Client/Server multiplayer games using QUIC
-
mireforge-examples
Examples for the mireforge 2D game engine
-
bevy_metrics_dashboard
Metrics dashboard for Bevy apps
-
bevy_stl
STL loader for bevy, based on stl_io
-
ludusavi
Game save backup tool
-
renderling
User-friendly real-time rendering. 🍖
-
micro_banimate
Easily manage complex Bevy 2D sprite animations
-
avian_pickup
A plugin for implementing picking up dynamic rigid bodies in Avian physics for the Bevy engine.Modeled after Half Life 2's gravity gun
-
rojo
Enables professional-grade development tools for Roblox developers
-
bevy_flycam
Basic first-person fly camera for the Bevy game engine
-
bevy-yoleck
Your Own Level Editor Creation Kit
-
iyes_progress
Bevy plugin to help implement loading states
-
golem
A (mostly) safe library for graphics programming
-
hobo
frontend framework
-
steamworks
friendly bindings to the steamworks sdk
-
virtual_joystick
Bevy virtual Joystick for mobile games
-
bevy_vox_scene
A Bevy engine plugin for loading Magica Voxel world files and render materials directly in Bevy as a scene graph
-
bevy_behave
A behaviour tree plugin for bevy with dynamic spawning
-
bevy_third_person_camera
A third person camera written for Bevy
-
pyri_state
A flexible
bevy_statealternative -
bevy_slinet
networking plugin for bevy
-
polyanya
Polygon Any Angle Pathfinding
-
swamp-vm
Minimial virtual machine
-
bevy_basic_portals
A portal plugin for Bevy game engine
-
maple
A 3D game engine
-
bevy_aseprite_ultra
A Bevy plugin for directly loading spritesheets and animations from aseprite binary files with hot reloading support
-
keyframe
animation in Rust
-
smaa
post process antialiasing using SMAA
-
game_features
Various helpful constructs for game development. See the github repository for detailed instructions.
-
bevy_procedural_meshes
Procedural Meshes for the Bevy game engine
-
aeronet
Low-level networking for Bevy
-
fyrox
Feature-rich, easy-to-use, 2D/3D game engine with a scene editor. Like Godot, but in Rust.
-
avian3d
An ECS-driven physics engine for the Bevy game engine
-
lotus_engine
Lotus is a game engine with the main focus of being easy-to-use and straight forward on developing 2D games
-
tyche
Dice rolling and dice expression (with a syntax similar to FoundryVTT) parsing library
-
acc_shared_memory_rs
reading Assetto Corsa Competizione shared memory
-
bevy_image_font
Render pixel fonts from PNGs in Bevy
-
bevy_prototype_lyon
Draw 2D shapes and paths in the Bevy game engine
-
bevy_fog_of_war
A 2D fog of war plugin for Bevy
-
bevy_console
dev console for bevy
-
buffer-graphics-lib
graphics library for buffers
-
gyges
board game Gygès
-
noisy_bevy
Procedural noise primitives for Bevy
-
moonshine-behavior
Minimalistic state machine for Bevy game engine
-
valheim-mod-manager
Mod manager for Valheim game
-
chessgen
Chess moves generator
-
wow-mpq
Parser for World of Warcraft MPQ archive files (1.12-5.4)
-
backgammon
The Rust Backgammon library
-
apecs
An asyncronous and parallel entity-component system
-
bevy-discord
A bevy plugin for sending and receiving discord messages
-
bevy_northstar
A Bevy plugin for Hierarchical Pathfinding
-
hapi-rs
Rust bindings to Houdini Engine API
-
bevy_ggrs
Bevy plugin for the GGRS P2P rollback networking library
-
bevy_ineffable
A simple-to-use input manager for bevy that empowers players and makes accessibility easy
-
bevy_simple_text_input
Bevy plugin for a simple single-line text input widget
-
gdt-cpus
Game Developer's Toolkit for CPU Management
-
bevy_hui
pseudo Html templating ui crate for the bevy-engine
-
bevy_mod_index
Allows using indexes to efficiently query for components by their values in the game engine Bevy
-
rafx
Rendering framework built on an extensible asset pipeline
-
bevy_light_2d
General purpose 2d lighting for the Bevy game engine
-
landmass
A navigation system for video game characters to walk around levels
-
spire_tween
A Slimy tweener library for Godot(4.4+), inspired on the design of DoTween(3rd party package for Unity)
-
gw2lib-model
Models for gw2lib
-
pak
data pak format for games
-
resonite
Resonite's API in rust
-
shen-nbt5
Just A FASSST NBT parser/writer
-
bevy_macro_utils
A collection of utils for Bevy Engine
-
gba
‘raw’ style GBA development. If you want a ‘managed’ experience, try the
agbcrate instead. -
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
sdl3-sys
Low level Rust bindings for SDL 3
-
chuot
AGPL licensed and opinionated game engine for pixel-art games
-
playdate
High-level Playdate API
-
bevy_smud
2d sdf shape renderer plugin for Bevy
-
viriformat
data-representation used by the viridithas chess engine
-
ascii-forge
A Minimal TUI Ascii Application Engine that simplifies the use of crossterm
-
bevy_simple_tilemap
Refreshingly simple tilemap implementation for Bevy Engine
-
laminar
semi-reliable UDP protocol for multiplayer games
-
ascending_graphics
A graphical rendering library for 2D, using wgpu and winit
-
hotline-rs
A high-performance, hot-reload graphics engine
-
bevy_heavy
Mass property computation for Bevy's geometric primitives
-
good-web-game
An alternative implementation of the ggez game engine, based on miniquad
-
bevy_screen_diagnostics
Bevy plugin for displaying diagnostics on screen
-
smol-rgb
A smol library for (s)Rgb color handling
-
bevy_obj
Wavefront OBJ mesh asset loader plugin for the Bevy engine
-
crabslab
Slab allocator focused on GPU compute (rust-gpu)
-
geese
Dead-simple game event system for Rust
-
scryfall
A wrapper around the scryfall magic the gathering api
-
hnefatafl-copenhagen
Copenhagen Hnefatafl client, engine, and server
-
catgirl-engine
A game engine for cool moddability and procedurally generated data
-
stackr-rs
A stack-based interpreter to be embedded in your application. Heavily inspired by Forth.
-
dymod
A macro to allow hotswapping code for a module in debug mode, but statically linking it safely in release mode
-
bevy_replicon_attributes
Extends bevy_replicon with attribute-based visibility control
-
bevy_skein
Process glTF extras when spawning Scenes to insert Components using Reflection, such as when using Blender as an editor
-
chessie
Fast chess library, suitable for use in chess engines
-
russimp
Assimp bindings for rust
-
limnus-asset-registry
keeps track of asset lifetimes
-
bevy_text_edit
Bevy plugin for input text
-
bevy_audio_controller
Bevy plugin for managed audio playback
-
magpie
High-performance Othello library built with bitboards
-
bevy_minibuffer
A gamedev console inspired by classic Unix text editors
-
dfhack-remote
Interacting with the Dwarf Fortress remote API exposed by DFHack
-
cao-lang
The back-end of cao-lang, a node based visual scripting language
-
sprites7800
a companion tool of cc7800 generating C sprites/tiles code
-
bevy_mod_async
Ergonomic async tasks plugin for the Bevy game engine
-
yarnspinner
The friendly tool for writing game dialogue
-
pistoncore-sdl2_window
A SDL2 back-end for the Piston game engine
-
nav
handling cardinal directions and transformations
-
gdextension-api
Godot GDExtension API; used by godot-rust
-
sparsey
Entity Component System based on sparse sets
-
retrofire-core
Core functionality of the retrofire project
-
ndm
Parse standard polyhedral dice notation
-
bevy_vector_shapes
rendering vector shapes using the Bevy game engine
-
bevy_hourglass
A flexible hourglass plugin for Bevy applications
-
bevy-settings
struct as persistent settings between game launches. Usefull for e.g. storing the audio settings
-
gamepads
access information about connected gamepads
-
smooth-bevy-cameras
Bevy camera controllers with buttery, exponential smoothing
-
woodpecker_ui
A UI library for the Bevy game engine
-
bulls-and-cows
A framework for building bulls-and-cows games (1A2B) for any data type
-
pmd_wan
that can read wan file, a sprite format used in pokemon mystery dungeon games
-
bevy_mod_reqwest
Bevy http client using reqwest, with a focus on simple usage within the bevy runtime
-
bladeink
port of inkle's ink, a scripting language for writing interactive narrative
-
bevy_fps_controller
Bevy plugin that adds a Source engine inspired FPS movement controller
-
uesave
Unreal Engine save file (GVAS) reading/writing
-
pagurus
Ultra-portable game engine suited for offline 2D games powered by WebAssembly
-
bevy_embedded_assets
A Bevy plugin to embed assets in your game
-
bevy_rapier3d
3-dimensional physics engine in Rust, official Bevy plugin
-
anput
Scriptable Entity-Component-System (powered by Intuicio)
-
bevy_web_keepalive
Bevy plugins to keep a bevy app running in the browser despite not being visible
-
lf-gfx
A collection of utilities that we use
-
bevy_ui_text_input
Bevy UI text input plugin
-
bevy-persistent-windows
A Bevy plugin to easily create and manage windows that remember where they were
-
oxidized_navigation
A Nav-Mesh generation plugin for Bevy Engine
-
bevy_mod_xr
semi generic Xr Api for Community Driven XR in Bevy
-
bevy-convars
convars (config or console variables) for configuring your Bevy application
-
chron
A game loop with a fixed timestep
-
magma_ecs
Entity-Component-System for the Magma3D game engine
-
lightyear_examples_common
Common harness for the lightyear examples
-
impacted
2d collision test for arbitrary convex shapes
-
vpin
virtual pinball ecosystem
-
rollo
A Rust-based multiplayer framework
-
tiles7800
a companion tool of cc7800 generating tiling data from Tiled maps
-
bevy_mod_speedup
collection of ways to increase the performance of your application
-
stickup
A modular input device abstraction layer with HID and virtual device support
-
haalka
ergonomic reactive Bevy UI library powered by FRP signals
-
luau0-src
Minimal sources of Luau and logic to build them
-
simdnoise
SIMD accelerate noise library with runtime feature detection
-
rglua
Toolkit for garrysmod development with the source sdk and luajit api
-
bevy-async-ecs
Asynchronous interface for Bevy ECS
-
bevy_enoki
2D Particle system plugin, that works well on wasm and mobile
-
pix-engine
A cross-platform graphics/UI engine framework for simple games, visualizations, and graphics demos
-
evaluroll
A dice expression parser and evaluator
-
bevy_app_compute
An easy way to run compute shaders for Bevy
-
bevy_rich_text3d
Mesh based raster rich text implementation for bevy
-
bevy_rpack
Bevy plugin with rpack atlas support
-
ckc-rs
Poker hand evaluation library
-
bevy_ui_anchor
A small bevy plugin for anchoring UI elements to specific points or entities in the world
-
wow-wdl
Parser for World of Warcraft WDL (low-resolution terrain) files
-
licheszter
An API wrapper for the Lichess API
-
bevy_quadtree
A quadtree plugin for bevy
-
bevy_health_bar3d
Health bar for bevy implemented as a billboard shader
-
we_clap
Web Enabled Command Line Argument Parser
-
bevy_file_dialog
File system dialogs for loading and saving files using the Bevy game engine
-
bevy_spatial
tracking bevy entities in spatial indices
-
bevy_sorting
Sorting bevy systems based on reads and writes
-
arboriter-mcts
A Monte Carlo Tree Search implementation built on the arboriter tree traversal primitive
-
rusty_engine
Learn Rust with a simple, cross-platform, 2D game engine
-
lyceris
An open source Minecraft launcher library
-
rust_pixel
2d pixel art game engine & rapid prototype tools support terminal, sdl2, and web
-
cala
Make portable apps and video games in Rust!
-
bonsai-mdsl
parsing and executing behavior trees defined in MDSL (Mistreevous Domain Specific Language) into bonsai Behaviour Trees
-
bevy_gltf_trait
Customizable Bevy Engine GLTF loading
-
bevy_args
bevy plugin to parse command line arguments and URL query parameters
-
forky
Rust Utilities
-
pyxel-engine
Core engine for Pyxel, a retro game engine for Python
-
bevy_pixels
Bevy plugin that uses Pixels (a tiny pixel buffer) for rendering
-
bevy_bsml
A UI library to compose UI elements using simple markup language, inspired by svelte and tailwindcss
-
bevy_turborand
A plugin to enable ECS optimised random number generation for the Bevy game engine
-
big-brain
AI library
-
egui-wgpu
Bindings for using egui natively using the wgpu library
-
bevy_firework
CPU-driven, batch-rendered particle system for the Bevy 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.
-
bevy_magic_fx
Define mesh-based vfx in serialized files
-
pinmame-nvram
handling PinMAME NVRAM files
-
bevy-histrion-packer
A Bevy Plugin to pack all your game assets into a single common PAK like file format
-
z4
a command tool for Z4 game framework
-
bevy-earcutr
earcutr + Bevy
-
bevy_card3d_kit
a lib for put and use Card in 3d
-
bevy_pkv
Persistent key value store for apps/games
-
firefly_cli
CLI tool for working with Firefly Zero
-
chess-tui
chess game in your terminal 🦀
-
hex2d
Helper library for working with 2d hex-grid maps
-
egui_ratatui
Ratati Backend that is also an EGUI widget! WASM BEVY MACROQUAD EFRAME
-
bevy_synthizer
A Bevy plugin for Synthizer, a library for 3D audio and synthesis with a focus on games and VR applications
-
bevy_aspect_ratio_mask
A Bevy plugin for fixed aspect ratios, letterboxing, and UI scaling in 2D games
-
bevy_descendant_collector
Bevy crate to collect named entities into a single component
-
renom
program to rename Unreal Engine projects
-
bevy_life
Generic and dynamic cellular automaton lib for bevy
-
orthrus-ncompress
Orthrus module supporting Nintendo compression formats
-
bevy_transform_gizmo
A 3D transform gizmo for Bevy
-
pyri_tooltip
Powerful tooltips for Bevy
-
gorrosion
Go/weiqi/igo/baduk/goe whatchamacallit
-
bevior_tree
Behavior tree plugin for Bevy
-
gba_rumble
Rumble functionality on the Game Boy Advance
-
bevy_sun_move
A Bevy plugin for simulating realistic sun movement
-
nano9
A Pico-8 compatibility layer for Bevy
-
gametools
Game-related tools: spinners, dice, dominos, and cards
-
forte
A low-overhead thread-pool with support for non-static async closures
-
bevy_ui_extras
containing a collection of utilities to make working with ui in bevy easier
-
rmv-bevy-testing-tools
Write simple tests for bevy systems, using rstest, insta, and speculoos
-
dogoap
-
bevy_common_assets
Bevy plugin adding support for loading your own asset types from common file formats such as json and yaml
-
bevy_mod_imgui
A Dear ImGui integration for the Bevy game engine
-
basis-universal
Bindings for the basis-universal Supercompressed GPU Texture Codec by Binomial
-
luminol
FOSS recreation of RPG Maker XP in Rust with love ❤️
-
bevy_quill
A reactive UI framework for Bevy
-
bevy-butler
making Bevy systems more self-documenting
-
raylib-wasm
raylib native/wasm bindings
-
sisyphus32
Feature-based UCI Chess Engine
-
recompose
Declarative framework for the Bevy game engine
-
bevy_mod_skinned_aabb
A Bevy plugin that automatically calculates AABBs for skinned meshes
-
bevy_debug_log
Allows viewing tracing debug log output inside the bevy app using vanilla bevy_ui
-
tauri-plugin-gamepad
A plugin for Tauri that provides a polyfill for Gamepad Web API that works on most common platforms
-
ghx_proc_gen
2D & 3D procedural generation with WFC/Model synthesis
-
bevy_tailwind
TailwindCSS for Bevy
-
bevy_ecs_ldtk
An ECS-friendly ldtk plugin for bevy
-
pure_rng
rand-compatible RNG library for generating repeatable, controlled random values, designed primarily for use in games
-
devotee
Visualization engine
-
weirdboi_tween
Relationship based component value tweening for Bevy projects
-
bevy_cobweb
Reactivity primitives for Bevy
-
actuate
A reactive user-interface framework
-
bevy_serialization_extras
managing serialization with moonshine_save + wrappers
-
huawei-cloud-api-definitions-ECS
Huawei Cloud API definitions, generated from OpenAPI spec
-
bevy_state_curves
A state saving and management crate for the Bevy Game Engine saving via curve keyframes
-
rpgx
Lightweight, modular, and extensible RPG game engine 2D, designed for flexibility, portability, and ease of use
-
bevy_animations
2d Game Animation Engine built for Bevy
-
bevy_mod_kira
A plugin that integrates the Kira audio library for use in the Bevy game engine
-
bevy_mod_lockdown
reduce the attack surface your application offers
-
brawllib_rs
Brawl character file parser, based on brawlbox/brawllib
-
dbsdk-rs
API for creating Rust games for the DreamBox fantasy console
-
bevy_clay_tiles
A procedural-mesh building system for bevy
-
bevy_spectator
A spectator camera plugin for Bevy
-
gvas2json
Convert between GVAS and JSON or YAML
-
posturn
Build turn-based games with
asyncRust -
bosh-rs
A highly customizable physics engine for the game Line Rider
-
reverie-engine
A toy game engine
-
uvm-install2
Install specified unity version
-
froql
an in memory query dsl
-
bevy-paperdoll
Bevy plugin for 2D paper doll
-
agones
SDK for Agones
-
uuidmap
An ArrayHashMap implementation specialized for using a uuid (u128) as the key
-
riichi_hand
A collection of utilities for working with Riichi Mahjong player hands
-
bevy_time_runner
General timing system for the Bevy game engine
-
bevy_modern_pixel_camera
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
edges
getting the edges of objects in images with transparency
-
bevy_startup_tree
A bevy extension for inserting startup system dependency graphs into the app
-
bevy_stardust
A networking crate for the Bevy game engine
-
bevy-ui-navigation
A bevy plugin to make implementing ui navigation in your game a piece of cake
-
bevy-ichun
kinematic character controller for avian3d
-
gdnative_bindings_generator
Generates bindings for the Godot engine's gdnative classes from a json api description file
-
symbolic-unreal
Parsing and processing utilities for Unreal Engine 4 crash files
-
fmc
creating fmc servers
-
ploc-bvh
A Bounding Volume Hierarchy based on PLOC
-
bevy_text_popup
Easily create temporary text pop-up nodes in the Bevy game engine
-
roead
Rust port of oead C++ library for common Nintendo formats
-
revy
Proof-of-concept time-travel debugger for Bevy, built with Rerun
-
ldtk_rust
LDtk 2D level editor to build games in Rust
-
rust_flightplan
Loads a flight plan from SimBrief and decodes it
-
common_x
common
-
pixels-graphics-lib
pixel graphics and GUI library
-
bevy_pathfinding
3D Bevy plugin that combines flowfield pathfinding with boid-based collision avoidance to move units smoothly. Great for RTS games!
-
mevy
A growing set of macros, which add witchcraft into bevy!
-
bevy_window_title_diagnostics
Logs Bevy diagnostics into the primary window title
-
emergent
Toolset for producing emergent gameplay for games written in Rust
-
oml-audio
Very basic, and thin abstraction of audio handling meant for games
-
voxelis
Sparse Voxel Octree DAG engine for building worlds, shaping matter, and mastering 3D space — powered by pure Rust
-
bevy_http_client
HTTP client for Bevy
-
ABC-ECS
fast, and flexible Entity-Component-System library for Rust
-
bevy_jpeg2k
JPEG 2000 image loader for Bevy
-
our_economy_engine
Engine for the game Our Economy. Currently unusable, and progressing through rapid prototyping. Will often be half made, and be missing stuff.
-
bevy_pixel_buffer
draw pixels in bevy
-
casino_poker
that provides hand ranking & the backend for poker games
-
beet
Tools for building reactive structures
-
gvrtex
interfacing with the GVR texture format used on GameCube/Wii
-
bevy_2dviewangle
Bevy plugin for easier to switch texture base on view angles
-
bevy_quick_response
A Bevy plugin for quick responsive behaviors
-
bevy_lit
A lighting 2d library for Bevy
-
tetra
2D game framework written in Rust
-
bevy-alt-ui-navigation-lite
A bevy plugin to make implementing ui navigation in your game a piece of cake
-
unity-native-plugin
Unity Native Plugin API for Rust
-
bevy_tts
Text-to-speech for the Bevy game engine
-
seldom_pixel
Bevy plugin for limited color palette pixel art games
-
thallium
A basic game engine
-
bones_lib
The Bones game development library
-
famiq
Experimental GUI library, powered by Bevy engine
-
hexga_engine_base
The heart of the Hexga Game Engine, implementation free
-
krunker-maze-generator
Generates mazes for Krunker maps
-
piston2d-graphics
2D graphics that works with multiple back-ends
-
bevy_replicon_snap
High-level networking crate that extends the bevy_replicon crate to allow snapshot interpolation and client-side prediction
-
blue_engine
General-Purpose, Easy-to-use, Fast, and Portable graphics engine
-
gamie
abstractions for several classic tiny games
-
yunfengzh_monolith
Monolith is a framework based on tokio and bevy
-
micro_bevy_world_utils
Handy, reusable utilities for working with direct world access in a Bevy exclusive system
-
bevy_gltf_blueprints
Adds the ability to define Blueprints/Prefabs for Bevy inside gltf files and spawn them in Bevy
-
rsffish
wrapper for fairystockfish based on https://github.com/mind-sports-games/Fairy-Stockfish-Lib
-
arcade_jump
Arcade jump trajectory configurator
-
neuro-sama
that implements the Neuro-sama game API
-
bevy_variable_property
A generic way to define properties as static, random, or randomized on an interval
-
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
-
dcso3
Minimal Rust binding to the DCS lua api
-
bevy_despawn_particles
An event-based plugin for Bevy to spawn particles on despawn that are built from the original texture
-
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.
-
veloren-serverbrowser-api
the format of the veloren serverbrowser, so it can be used by other tools
-
oktree
Fast octree implementation
-
bevy-trait-query
trait queries for the bevy game engine
-
syn-locator
source code locator for syn crate
-
bevy-steamworks
A Bevy plugin for integrating with the Steamworks SDK
-
bevy_log_events
A Bevy plugin that helps to log events
-
bevy_2d_screen_space_lightmaps
Lighting plugin for 2D games made in the Bevy engine. This plugin uses the screen space lightmaps technique
-
widgetui
A bevy like widget system for ratatui and crossterm
-
gemini-engine
A 2D/3D monospaced ASCII rendering engine for the terminal
-
bevy_fast_tilemap
A GPU accelerated tilemap for bevy
-
bevy_entitiles
A 2d tilemap library for bevy. With many useful algorithms/tools built in.
-
interpulse
interacting with pulseflow apis
-
ra2-types
Shared types definitions for Red Alert 2
-
dynasty-rs
A powerful class inheritance system for Rust game engines
-
bevy_webserver
A web server integration for the Bevy game engine that allows you to easily append a webserver to Bevy
-
inkling
Limited implementation of the Ink markup language
-
bevy_magic_light_2d
Experimental dynamic 2D global illumination system for Bevy, based on SDF ray-marching and screen space irradiance cache probes
-
chilloutvr
Unofficial rust types of ChilloutVR's API
-
bevy_blendy_cameras
Bevy editor like cameras controls for Pan/Orbit/Zoom and Fly mode. Switch mode, set camera viewpoint and frame view around entities
-
bevy_wind_waker_shader
A toon shader that looks like the one used for characters in The Legend of Zelda: The Wind Waker
-
bevy-egui-kbgp
Better keyboard and gamepad story for egui in Bevy
-
gdext_coroutines
Run Rust Async functions and Coroutines in Godot 4.4+ (through GDExtension), inspired on Unity's Coroutines design
-
teng
A basic game engine for the terminal
-
mrdirector
A narrative game development package for the Turbo Game Engine
-
libmancala
A frontend-agnostic library that implements the game of Mancala
-
bevy_vox
Load MagicaVoxel Vox file for bevy engine
-
tiqtak
Checkers engine
-
fyrox-math
Math utils for the Fyrox engine
-
wow-wdt
parsing, validating, and converting World of Warcraft WDT files - tested on 100+ real WDT files
-
bevy_framebuffer
Bevy framebuffer rendering using the
pixelsandsoftbufferbackends -
chara
Parser for layered character definition files
-
rpkg-rs
Parse Glacier ResourcePackage (rpkg) files, allowing access to the resources stored within
-
dds-bridge
API for DDS, the double dummy solver for bridge
-
bevy_mod_observable_timer
An observer-based timer for bevy
-
deckbuilder_eng
A modular engine for deck-builder games with egui UI, audio, and card/deck/game logic
-
mesh-tools
generating 3D meshes and exporting them to glTF/GLB files
-
bevy_simple_scroll_view
plugin implementing ScrollView into Bevy engine
-
bevy_serial
Serial Port Communication Plugin for Bevy
-
bevy-fps-counter
FPS counter plugin for Bevy
-
bevy_sync
Plugin for synchronizing entities and components between server and its clients
-
bevy_ios_gamecenter
Bevy Plugin and Swift Package to provide access to iOS native GameKit (Gamecenter) from inside Bevy Apps
-
trecs
a tiny and easy to use ecs library
-
cliw
Command Line In Web
-
roblox-rs-core
Core compiler for translating Rust code to Luau for the Roblox platform
-
allegro_examples
Allegro 5 wrapper examples
-
obel_platform
Platform agnostic support
-
hexlab
A hexagonal maze generation and manipulation library
-
spatial_hash_3d
3D spatial hash grid implementation optimized for speed. What it does/why you'd want one: https://www.youtube.com/watch?v=sx4IIQL0x7c
-
saft
Signed distance field function compiler/interpreter/discretizer/mesher
-
bevy_ort
bevy ort (onnxruntime) plugin
-
bevy_webview_wry
Allows you to create a webview based on wry
-
lina
Linear algebra library with a focus on 3D applications like games (i.e. low-dimensional vectors and matrices)
-
naia-bevy-shared
faciliate naia & Bevy interop, functionality shared by client & server versions
-
break-eternity
A numerical library to represent numbers as large as 10^^1e308 and as 'small' as 10^-(10^^1e308)
-
bevy_tileset
configurable tilesets in Bevy using RON
-
gdman
A CLI application for managing versions of Godot
-
bevy_mod_rounded_box
A rounded box shape for Bevy
-
bevy_gizmo_log
Render bevy gizmos by logging them
-
bevy_interleave
bevy support for e2e packed to planar bind groups
-
re_log_types
The basic building blocks of the Rerun data types and tables
-
bevy_trickfilm
Bevy plugin for spritesheet manifest loading
-
macroquad_ldtk
LDtk integration with macroquad
-
bevy_ascii_terminal
terminal for rendering ascii in bevy
-
bevy_cards
no dependency bevy plugin for making card games
-
stockfish
Light, easy-to-use wrapper for the Stockfish engine
-
ambient_element
Element is a React-inspired virtual tree library for the Ambient runtime
-
bevy_scripting_rune
Script bevy games using rune
-
bz2-fastdl
Compresses source-engine game server files (maps, models, materials, etc.) using bzip2 for FastDL
-
tawa_lili
Internal runtime library of musi_lili
-
firefly-rust
Rust SDK for making Firefly Zero games
-
limnus-assets-loader
loads assets
-
oml-game
Game foundation extracted from Fiiish-RS to remove boilerplate for future procjects
-
rs2io
Types and utilities for processing io with a design heavily focused around the custom protocols used by the popular MMORPG Runescape
-
hecs-schedule
shedulable systems and parallel execution for hecs
-
bevy_pixcam
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
rbx_api
Make requests to Roblox's web APIs
-
meshtext
Generate vertex-vertex meshes from text
-
immediate_stats
Game stats that reset every frame, inspired by immediate mode rendering
-
bevy-parallax
A Bevy plugin for creating a parallax effect
-
ftvf
Temporal logic for writing a Fixed Tickrate, Variable Framerate game in Rust
-
bevy_rts_camera
An RTS-style camera for Bevy
-
smol-layout
a small layout utility for very simple pixel art games
-
bevy-renderdoc-capture
module for adding a RenderDoc application capture hook to Bevy apps
-
bevy_foliage_tool
A configurable foliage painting system using perlin noise, grayscale maps, and chunked visibility
-
revier-glam
Modification of the library glam-rs for the game engine Revier
-
bevy_ratepace
bevy_ratepaceis a crate to configure the update frequency of headless bevy -
rsmod-pathfinder
A breadth-first search path finder
-
godot-bevy
Bridge between Bevy ECS and Godot 4 for Rust-powered game development
-
bevy_particle_systems
A particle system plugin for Bevy
-
bevy_spine
Spine plugin for Bevy utilizing rusty_spine
-
tinystorm
but powerful framework designed primarily for building simple testing low-level games
-
bevy_map_camera
3D Camera Controller for Bevy
-
bevy_mqtt
A robust, secure MQTT client plugin for Bevy game engine with comprehensive error handling and performance optimizations
-
bevy_mod_billboard
Billboard text and texture support for bevy
-
bevy_logic
A logic gate simulation plugin for Bevy
-
sdl2
SDL2 bindings for Rust
-
collider
continuous 2D collision detection for game developement
-
bevy_simpletoon
A super simple post processing toon shader
-
dos-like
Framework for writing DOS-like applications
-
notation_core
Fun notation - definition for core concepts
-
terra-items
enum contatining terraria items and prefixes
-
bevy_fly_camera
A basic flying camera in Bevy
-
rlifesrc
A Game of Life pattern searcher
-
azalea-entity
Things related to Minecraft entities used by Azalea
-
flax
An ergonomic archetypical ECS
-
steam-vent-proto-steam
Protobuf structs used by the Steam client protocol for Steam
-
ruscii
Terminal graphics engine
-
bevy_actify
An input action plugin for Bevy
-
bevy_support_misc
My tiny common code to share between bevy game projects
-
bevy_replicon_quinnet
Integration with bevy_quinnet for bevy_replicon
-
terra-plr
Terraria player parser
-
dice_expression
help you parse and execute some dice expressions
-
rekt_lib
Common lib to use the RekT protocol. See the crate homepage to check the protocol RFC.
-
remodel
read, modify, and write Roblox objects
-
buttons
API for storing and querying input state
-
hexglobe
generate hexagonal tessellations of a sphere quickly and accurately
-
mapgen
Map generator for games (dungeons, worlds etc.)
-
bevy-panic-handler
A Bevy plugin that creates a popup message and logs to error on panic
-
be_tween
Helper library to support tweening - with inital support for bevy
-
sursface
Small cross-platform rendering library
-
mun_target
Describes compilation targets for Mun
-
bevy_family
that helps with creating, updating, and removing parent-child components in Bevy
-
ruci
A UCI (Universal Chess Interface) crate
-
double_dot_state
State management crate built for the Bevy game engine
-
bevy_novel
Visual Novels with Bevy
-
instant-glicko-2
Glicko-2 rating system that allows for instant feedback after games, not just once a rating period closes
-
bevy_silk
Cloth physics implementation in bevy
-
fyrox-resource
Asset management crate for the Fyrox engine
-
bevy_generative
Procedural generation in Bevy
-
ns_game
lib
-
bevy_mod_osc
OSC plugin for Bevy engine
-
epicinium_lib
Rust bindings for libepicinium, the game logic library of the strategy game Epicinium
-
quicksilver
game framework for 2D games in pure Rust
-
roblox-studio-utils
Cross-platform library for interacting with Roblox Studio
-
macroquad-canvas-2d
Add canvas functionality to macroquad
-
rpg-stat
computer stats for RPG game development
-
horfimbor-time
Time calculator for the Horfimbor game
-
seldom_map_nav
Bevy plugin that does navmesh generation, pathfinding, and navigation for tilemaps. Navmesh generation is available without Bevy dependency.
-
leafwing_abilities
A convenient, well-tested ability management suite. Built for the Bevy game engine.
-
rust_game_engine
Rust Game Engine
-
bevy_dev
Dev tools for Bevy Engine
-
pocketcraft_engine_api
API to interface with the PocketCraft Engine
-
tatami-dungeon
A roguelike dungeon generation algorithm
-
bugsyth_engine
little framework using glium
-
bevy_eventlistener
Event listeners and callbacks for bevy
-
bevy_cursor_kit
A Bevy plugin for working with cursors
-
mtdf
A (bad) Rust implementation of the MTD(f) algorithm
-
caption-compiler
Compiles and describes Valve's closed caption files
-
sapp-jsutils
Helper functions for working with js objects in miniquad based apps
-
bevy_cached_query
high level query library for Bevy based on async tasks and Observer API very loosely inspired by TanStack Query
-
aline
2d linear algebra library suitable for no_std
-
wow-m2
A parser for World of Warcraft M2 model files with version conversion support
-
ege
Small easy to use game engine
-
moonshine-kind
type safety solution for Bevy
-
reverie-util
reverie-engine
-
bevy_mod_aseprite
A plugin for using Aseprite animations in Bevy
-
bevy_la_mesa
Build card games with Bevy
-
bevy-tnua-physics-integration-layer
Components for integrating physics backends with bevy-tnua
-
bevy_pipelines_ready
Bevy plugin for tracking render pipeline status
-
giga-chess
chess library built for performance, handling game logic and legal/best move generation
-
twee-tools
A compiler for Twine stories
-
sara_ecs
ecs library made for study purposes
-
vrc
Unofficial rust types of VRChat's API
-
bevy_background_compute
Bevy plugin for better task handling
-
botw-utils
various utilities for modding Breath of the Wild
-
gmod
A swiss army knife for creating binary modules for Garry's Mod in Rust
-
game_stat
handling stats that can change with modifiers, most commonly seen in games
-
bevy_march
SDF ray marching for bevy
-
blinds
Wrap an async abstraction over a window
-
pons
Rust package for contract bridge
-
bevy_cronjob
helper to run cronjobs (at repeated schedule) in Bevy
-
naia-bevy-client
faciliate naia_client & Bevy interop
-
aalo
aka bevy-inspector-haalka, a bevy_ui-native inspector for Bevy
-
bevy_crossbeam_event
Fire Bevy events from crossbeam channels
-
csa
A Shogi game serialization/deserialization library in CSA format
-
bevy_outline_post_process
An adaptive outline post-processing effect for the Bevy game engine
-
collision2d
2d collision detection library
-
bevy_fluent
Bevy plugin for localization using Fluent
-
bevy_local_commands
local shell commands for the Bevy game engine
-
adam_fov_rs
Adam Milazzo's FOV algorithm http://www.adammil.net/blog/v125_Roguelike_Vision_Algorithms.html#mine
-
bevy_cursor
A bevy plugin to track information about the cursor
-
bevy_play_card
A card crate for the Bevy game engine
-
ck3-tiger
Validator that checks Crusader Kings 3 user mod files for mistakes and warns about them. For example: missing localizations, or using a faith trigger on a character. Crusader Kings…
-
bevy_two_entities
A few convenience traits for working with Bevy Queries
-
qbsp
parsing and operating with Quake 1 BSP files
-
rusty_sword_arena
Library/repository for the half-day Rust tutorial teaching you how to make a game client in Rust
-
endgame
A turn-based game engine
-
bevy_flair
Bevy UI styling using CSS
-
bevy_midix
The MIDI plugin for humans. Out-of-the-box soundfont synthesizer, commands, and input!
-
xecs
An Entity-Component-System library
-
bevy_serde_lens
Blazingly fast, schema based human-readable serialization crate for the bevy engine
-
wow-adt
Parser for World of Warcraft ADT (terrain) files
-
bevy_spawnable
tiny spawn utility for Bevy, to encapsulate spawn logic
-
schnapsen-rs
Schnapsen implementation in Rust
-
wow-blp
Parser for World of Warcraft BLP (texture) files
-
event-simulation
event based simulation of application state
-
bevy_coroutine
run coroutines in Bevy
-
bevy_app
core App functionality for Bevy Engine
-
oxygengine
Oxygengine
-
igdb
Video Game Database Api
-
daedalus
querying and parsing Minecraft metadata
-
bevy_dolly
The dolly abstraction layer for the bevy game framework
-
lotus-shared
Shared code for LOTUS scripts and engine
-
sceller
An ECS crate written in Rust based on the tutorial series by Brooks Builds on Youtube
-
simple-game-utils
games
-
bracket-lib
Meta-crate holding the entirety of bracket-lib (and exposing it). Use this for the full roguelike toolkit experience.
-
macrogrid
work with grids in macroquad
-
shrev
Event channel, meant to be used with
specs -
ambient_proxy
NAT traversal proxy for Ambient game engine
-
rship-entities
rship entities
-
rpgx-dioxus
Dioxus plugin for the RPGX engine
-
bevy_round_ui
rounded-rect material shader for bevy_ui
-
pyxel-platform
Platform abstraction layer for Pyxel, a retro game engine for Python
-
raywoke
Extremely simple raycasting crate
-
magma_app
Part of the Magma-API, which is the API of the Magma3D game engine
-
sustenet
A networking solution for MMOs and large multiplayer games. It includes a master server, cluster servers, a client library, and authentication.
-
limnus-basic-input
platform neutral input types
-
hive-engine
A game engine for Hive
-
bevy_xr_utils
utils for bevy_mod_xr and bevy_mod_openxr
-
uci
programmatically communicate with UCI compatible chess engines
-
bevy_lazy_signals
An ad hoc, informally-specified, bug-ridden, kinda fast implementation of 1/3 of MIT-Scheme
-
vrc-get-vpm
Open Source client of VRChat Package Manager. This is the library is made for vrc-get.
-
repath
A fast pathfinding library using A* algorithm, caching, precomputation and path segmentation with concurrent pathfinding
-
dfhack-proto
Generated code from the DFHack API
-
corrosive-ecs-core
Core Functionality of Corrosive Engine
-
uci-parser
Universal Chess Interface parser
-
mod_plugins
Reduce plugin boilerplate in the Bevy game engine
-
squirrel-rng
An impl of
rand::Rngbased on a talk by Squirrel Eiserloh re: Math for Game Programmers -
egor
A dead simple 2D graphics engine
-
rafx-base
Rendering framework built on an extensible asset pipeline
-
gravitron
A GameEngine based on an ECS and Vulkan
-
notan_egui
EGUI support for Notan
-
world_dispatcher
System part of a full ECS, along with a fast dispatcher and world container
-
bevy_quickmenu
way of quickly creating nested menus in bevy that can be navigated with keys, gamepads and pointers
-
decrunch-unity
Decoder for crunch-compressed texture data, using the Unity fork of the crunch library
-
erupt-bootstrap
vk-bootstrap for Rust
-
bevy_jornet
Bevy plugin for Jornet - a social game server
-
wgsl_preprocessor
An unofficial preprocessor for WGSL written in Rust for WGPU
-
bevy-ui-dsl
A DSL library that simplifies the creation of widgets for bevy_ui
-
micro-games-kit
Micro Games Kit
-
pixel-game-lib
AGPL licensed and opinionated game engine for pixel-art games
-
bevy_mod_bbcode
Use BBCode-formatted text inside of Bevy
-
cosync
a single threaded, sequential, parameterized task pool for games
-
bevy_full_throttle
Enable CPU performance mode for Bevy games
-
swamp-vm-instr-build
builds opcodes for the swamp vm
-
nnsdk
Cleanroom reverse-engineered bindings for nnsdk (Nintendo Switch SDK)
-
shogi_core
Fundamental types and functions for shogi
-
bevy_simple_compute
App compute plugin for Bevy
-
bevy_mod_inverse_kinematics
An inverse kinematics plugin for the Bevy engine
-
bevy_log
logging for Bevy Engine
-
bevy_debug_panel
show debug info to panel
-
NovaEngine
An ECS Engine
-
degen_toon_terrain
heightmap terrain plugin for Bevy game engine
-
micro_autotile
LDTK autotiling
-
hephae
A personalized, opinionated Bevy plugin that adds support for drawing and batching arbitrary vertices and indices
-
bevy_gearbox
State machine system for the bevy game engine
-
colider_lib
A bevy collider crate
-
bevy_mod_scripting
Multi language scripting in Bevy
-
bevy_material_tool
A material replacement workflow for bevy
-
lib-curveball
Curve generating utility for Neverball
-
bevy_gamepad
Apple Game Controller Framework Integration plugin for Bevy
-
bevy_link_window_to_monitor
A small micro-crate to associate Windows and Monitors
-
kludgine
A wgpu-powered 2d graphics library with optional windowing support
-
bevy_ehttp
A ehttp client plugin for Bevy
-
mcpack
A CLI tool for managing minecraft datapacks
-
bevy_flicker
An easy to use event-based system to apply brief overlays to sprites and meshes
-
bevy_proto
Create config files for entities in Bevy
-
ucui
A minimal UCI engine frontend experiment
-
argentum_game_coordinate_system
Argentum: Coordinate System
-
big_space
A floating origin plugin for bevy
-
krait-engine
A game engine that I'm working on
-
naga-to-tokenstream
Creates a TokenStream describing parts of a Naga module
-
bevy_bundlication
Replication rules for bevy_replicon based on a bundle pattern
-
swamp-script-analyzer
analyzer for swamp script
-
bevy-yoetz
A decision-making AI for the Bevy game engine
-
moonshine-view
Generic Model/View framework designed for Bevy
-
ici-files
Encode/decode ici files
-
bevy_landmass
A plugin for Bevy to handle navigation of AI characters
-
inexor-rgf-core-plugins
Inexor - Reactive Graph Flow - Core - Plugins
-
rantz_spatial2d
A set of 2D spatial utilities for Bevy, including handling transform propagation
-
bevy_shuffle_bag
shuffling collections in Bevy
-
worlds
Game Engine
-
moecs
Micro ECS engine. A small and lightweight ECS engine for Rust projects.
-
iyes_loopless
Composable alternatives to Bevy's States/FixedTimestep/RunCriteria
-
bevy_mesh_obj
Parse Wavefront .obj files into Bevy Meshes
-
checs
An Entity-Component-System library
-
cecs
Entity database for the game 'Cao-Lo'
-
bevy_script_api
Bevy API for multiple script languages, part of bevy_mod_scripting
-
glam-ext
Transform, isometry and more extension types for glam-rs
-
rust-rpg-toolkit
An engine for creating action RPGs with Rust and/or JSON
-
dbsdk-cli
Command-line utility to simplify building Rust games for the DreamBox fantasy console
-
bevy_stat_query
Blazing fast and versatile RPG stat system for the bevy engine
-
bevy_channel_trigger
Send events via a channels form anywhere (eg. c-ffi) to Bevy Observers
-
bevy_window_utils
window utils such as managing window icon and taskbar progress indicator in Bevy
-
bevy_web_popups
Allows to trigger web/dom based popups/alerts and textinput in bevy
-
bevy_query_macros
Bevy query macros
-
bevy_camera_shake
Adds camera shake to your cameras in Bevy Games
-
obel_dylib
Force the obel Engine to be dynamically linked for faster linking
-
rsbuf
A RuneScape update info computer
-
warbler_grass
A bevy plugin for creating 3d grass in your game
-
godot-binary-serialization
A Godot binary serializer to encode & decode types from & to godot
-
procedural_modelling
A framework-agnostic Procedural Modelling crate
-
flywheel
Open-source, cross-platform 2.5D game engine built on SDL3
-
inv-sys
effective inventory system for games
-
bevy-ui-gradients
Bevy UI gradients plugin
-
ldtk2
A thin crate for people who just want to use ldtk files freely
-
wutengine_editor
editor for WutEngine games
-
fyrox-template
Command line interface for project template generator for Fyrox engine
-
ra2-shp
Parser for Red Alert 2 shape files (*.shp)
-
horfimbor-jwt
Jwt handler for the game engine Horfimbor
-
pico8_decompress
Decompresses Pico-8 text
-
bevy_roll_safe
Rollback safe utilities and abstractions for Bevy
-
raycaster
A multi-threaded raycaster engine for creating game graphics similar to Wolfenstein3D
-
distance-field
Generate distance fields from images for pseudo-vector rendering
-
bevy_iced
Iced integration for Bevy
-
ticktime
struct to convert a tick to an in game date time
-
farver
color library with easy transformation of colors with less functions
-
bevy_match3
A logic library for quickly adding a match-3 system to any bevy project
-
mtnrust
start for rust publish done by Metin Ilhan, will be improved later
-
bevy_spacetimedb
Use SpacetimeDB in your Bevy application
-
bracket-pathfinding
Pathfinding and field-of view utilities. A Star, Dijkstra. Part of the bracket-lib family.
-
flecs
Rust bindings for the Flecs Entity Component System
-
bevy_input_prompts
Mappings from bevy input types to popular input prompt asset paths
-
bevy_dither_post_process
A post-process black and white ordered dithering effect for the Bevy game engine
-
bevy_eulerian_fluid
An eularian fluid simulation plugin for Bevy
-
turbo_atlas_icons
A system for declarative ui icon rendering with Bevy
-
gojira
A refreshingly simple data-driven game engine and app framework
-
magma_winit
Part of the Magma-API, which is the API of the Magma3D game engine. A winit windowing backend implementation.
-
bevy_terminal_display
A plugin for the Bevy game engine which enables rendering to a terminal using unicode braille characters
-
hot_potato
hot reloading library for development
-
throne
Game scripting language for rapid prototyping and story logic
-
bevy_blur_regions
A Bevy plugin to selectively blur regions of the screen
-
gdnative
The Godot game engine's gdnative bindings
-
maze_rs
maze game in rust
-
wow_dbc
parsing World of Warcraft DBC files for 1.12, 2.4.3 and 3.3.5
-
crow
A pixel perfect 2D rendering engine
-
bevy_mod_krita
Use Krita's .kra files directly in your Bevy app
-
piston
game engine core libraries
-
amethyst_tools
Game development tools for the Amethyst engine
-
bscore
bowling score library for Rust
-
intrepid
Manage complex async business logic with ease
-
bevy_flurx_ipc
way for ipc communication using bevy_flurx
-
qwac
Rust client crate for making qwac games
-
min_timer
f64 based duration and timer; moreover, a main loop implementation using it
-
pixel8bit
applying 8-bit pixelation effects with symmetry detection and mirroring
-
fts_units
that enables compile-time type-safe mathematical operations using units of measurement
-
gn-communicator
Component for communication for game-night microservices
-
musi_lili
retro game engine for GB styled games written in Rust. Inspired by pico8.
-
quaturn
A 3D game engine written in Rust
-
raster-fonts
Bitmap font creation tool and accompanying metadata deserialization library
-
bevy_edge_detection
A bevy plugin adding edge detection post processing effect
-
ccdb
A small terminal based game engine
-
raylib-sys
Raw FFI bindings for Raylib
-
bevy_text_mode
Bevy plugin adding a texture atlas sprite with configurable background and foreground colors
-
solstack
Enables management of your app's or game's control flow through a simple state stack machine
-
dodgy_2d
ORCA, a local collision avoidance algorithm for 2D
-
schminput
An Action Based Input Manager for Bevy
-
bevy_simple_i18n
Bevy i18n plugin
-
weasel
A customizable battle system for turn-based games
-
dexterous_developer
A modular hot reload system for rust
-
rubot
A generic game bot written in Rust
-
bevy_compute_noise
A Bevy plugin for generating tilable 2D/3D noise textures using compute shaders
-
uesave_cli
Unreal Engine save file (GVAS) reading/writing
-
chess-oxide
A chess engine library written in Rust, with a GUI bin to play against it
-
bevygap_shared
Shared plugin used by bevygap plugins and related tools
-
bevy_rectray
A minimal 2d layout system for bevy
-
stourney
Splendor tournament manager - an app for running Splendor tournaments between autonomous agents
-
bevy_ui_forms
A bevy plugin for creating forms
-
ftw
A CLI tool to manage your godot-rust projects!
-
bevy_gauge
designed to provide an opinionated solution to handling stats, effects, abilities and tags
-
torchbearer
Find your path in darkerer dungeons
-
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
-
bevy_guessture
Bevy plugin wrapping the
guessturecrate’s gesture recognition API -
bevy_egui_next
A plugin for Egui integration into Bevy
-
bevy-scene-hook
Ad-hoc component insertion for bevy scenes
-
bevy_simple_screen_boxing
but small, crate that aims to make Letter/Pillar Boxing in Bevy easy
-
ck3oop-core-rs
ck3oop
-
limnus-system-params
Limnus system parameters
-
rantz_proto
An opinionated rust library for transforming on-disk assets into Entities in Bevy
-
allegro_util
Rust Allegro 5 wrapper utilities
-
sdl2-sys
Raw SDL2 bindings for Rust, used internally rust-sdl2
-
tge
A lightweight cross-platform 2D game framework written in pure Rust and based on OpenGL 3.3+
-
rust_airport_supplier
Rust-AirportSupplier downloads airport data from OurAirports and decodes the information
-
bevy_dioxus_desktop
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
bevy_mod_gba
Platform support for the GameBoy Advance with the Bevy game engine
-
urex
wip UnityRustExtractor and patcher
-
nrd-sys
Rust FFI for NVIDIA Realtime Denoiser
-
bevy_registration
Run code on the app from far away
-
otter-wasm
Otter game system; Rust WASM crate
-
bevy_ogle
A camera library for 2d vector games
-
cuicui_chirp
A file format based on cuicui_dsl to describe bevy UIs
-
bevy_c3d
A plugin for loading C3D motion capture files into Bevy
-
wrapped2d
Rust binding for Box2D
-
fyrox-graph
Graph management crate for the Fyrox engine
-
brood
A fast and flexible entity component system library
-
rantz_random
Mostly just a wrapper around fastrand for a bunch of types. Supports bevy and rantz_spatial2d.
-
bevy_eventwork_mod_websockets
A Websocket NetworkProvider for Bevy_eventwork
-
bevy_falling_sand
Falling Sand simulation plugin for Bevy
-
inexor-rgf-core-di
Inexor - Reactive Graph Flow - Dependency Injection
-
transform-gizmo-bevy
bevy integration for transform-gizmo
-
bevy_editor_pls
In-App editor tools for bevy apps
-
legion
High performance entity component system (ECS) library
-
tgr
Игровой движок на Rust
-
rust-sc2
StarCraft II API
-
bevy_2d_line
A line rendering plugin for Bevy
-
ghx_grid
2D & 3D grid structures & utilities
-
perovskite_server
Multiplayer voxel game written in Rust - Game server
-
bevy_2delight_anims
An fsm-driven 2d animation system that's _delight_ful to use
-
feo-oop-engine
An Object Oriented game engine for rust
-
bvh-arena
A bounding-volume hierarchy for in-game broad-phase collision detection
-
dummy-agones
Dummy Agones SDK server for developing Agones integrations
-
gdext-gen
Autogenerates a .gdextension file for using Rust to make a Godot GDExtension. It provides all the libraries pathfinding and a way to automatically link the default icons to the new…
-
cinnog
Data layer and helper methods for static site generation with Leptos
-
pixel_engine
A recreation of the olcPixelEngine by javidx9 written in Rust
-
bevy-rapier-baseball-flight
Baseball flight simulation with Bevy and Rapier
-
hecs-component-provider
Easily define behavior for sets of components when using the hecs ECS library
-
bevy_intro_screen
Highly customizable introductio n(splash) screen library for Bevy games
-
ogmo3
reading and writing Ogmo Editor 3 projects and levels
-
nightrunner_lib
A parser library for making text adventure games
-
bevy_fixed_update_task
A fixed update for bevy, unthrottled from bevy's default update loop
-
bevy_prototype_debug_lines
A prototype plugin providing a simple line drawing API for bevy
-
bevy-aabb-instancing
Render millions of AABB instances in Bevy
-
bevy-vfx-bag
An assorted bag of visual effects for Bevy
-
bevy_ratatui_render
A bevy plugin for rendering your bevy app to the terminal using ratatui
-
fixedstep
macro to create a fixed timestep loop for a game
-
squadleader
A type system and rule engine to model small unit infantry combat
-
bevy_mouse_tracking_plugin
A plugin for effortless mouse tracking in the bevy game engine
-
bevy_simple_prefs
A small Bevy plugin for persisting multiple Resources to a single file
-
geng
Game ENGine
-
bevy_mod_spatial_query
Spatially aware Queries for the Bevy game engine
-
uobors_core
Unleash OpenBOR modding in Rust
-
haalka_futures_signals_ext
vendored version of MoonZoon's futures_signals_ext, as it is yet to be released as a crate
-
bevy_doryen
A Bevy plugin that integrates the Doryen roguelike library with Bevy
-
bevy_button_released_plugin
Bevy helper crate that allows to react to button being released
-
service-locator
Thread-safe generic service locator
-
tetris_core
Tetris game model with no UI or Game engine
-
schachmatt
A chess library
-
bevy_prng
providing newtyped RNGs for integration into Bevy
-
bevy_radix_sort
A GPU-based radix sort plugin for Bevy
-
benimator
A sprite animation library for rust game development
-
mun_runtime_capi
C API for the Mun runtime
-
bracket-geometry
Geometry utilities. Rect, lines, circles, distance calculations. Part of the bracket-lib family.
-
bevy-progressbar
Create multi sectons progressbars and use them in the bevy ui
-
mooeye
A small UI library designed on top of the ggez game library. WORK IN PROGRESS
-
bevy_asset
asset functionality for Bevy Engine
-
bevy_query_ext
Extensions for Bevy's queries
-
gravitron_utils
Gravitron's Utils
-
steam-vent-proto-tf2
Protobuf structs used by the Steam client protocol
-
rectessellate
WIP — DO NOT USE!
-
treasury-import
FFI for treasury importers
-
better_button
Extend Bevy buttons with on-entered and on-exited events for press, hover and mouse over states
-
bevy_simple_scrollbar
scrollbar crate for Bevy
-
bevy_prototype_sdf
Experimental APIs for using Signed Distance Functions in bevy
-
ryot_ray_casting
Implements ray casting capabilities for Bevy, crucial for interactive game mechanics like line-of-sight, fog, complex collision, etc
-
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
-
bevy_simple_rich_text
A tiny rich text helper for Bevy
-
bevy_wasm
Run WASM systems in Bevy
-
bevy_titan
Bevy plugin for spritesheet manifest loading
-
shogi
Bitboard based Shogi library. Board representation, move handlings and various time control utilities.
-
obel_statechart
statechart plugin to implement complex game logics eg, behavior tree
-
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…
-
kira_qqbot
KiraFramework proc macro
-
deathframe
My game development framework for the amethyst game engine
-
bevy_midi
Send and receive MIDI data to and from bevy and other programs or controllers
-
chessai
a chiness chess ai
-
tf-asset-loader
loading assets from tf2 data files
-
bones_utils
Utilites used throughout the bones_framework
-
space-partitioning
Space partitioning data structures
-
thunderstore-api
API bindings for the Thunderstore Web API
-
planck_game_features
Integrates game_features with the planck_ecs library
-
secs
Shit Entity Component System
-
shade
graphics library
-
bitt
Bevy integration testing toolkit
-
bevy_xpbd_3d_parenting
Allows children of a
bevy_xpbd_3dRigidBodyto exert forces on their parents -
bevy_dae
A Bevy plugin for loading and rendering DAE (Collada) files
-
component_group
Defines the ComponentGroup trait for managing a group of specs::Component instances and moving them between specs::Worlds
-
bevy_crab_networking
Bevy plugin for sending data over TCP
-
crystalorb
Network-agnostic, high-level game networking library
-
notan_extra
extra features or plugins for Notan
-
bevy_talks
A Bevy plugin to write dialogues for your characters to say and do things, together with player choices
-
zcomponents
stupid component storage
-
renru_engine
Moteur de jeu pour Ren'Ru
-
xwt
A common WebTransport interface for browser and native. Write once, run anywhere. Originally intended for use with bevy.
-
notation_fretted
Fun notation - definition for fretted instruments
-
chidori-debugger
Visual debugger for Chidori
-
bevy_simple_preferences
Preferences API for Bevy
-
space_editor
Prefab editor for bevy game engine. Make levels/object templates with intuitive UI
-
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)
-
lictl
A command line interface for scripting Lichess
-
bevy_ui_builder
ui builder library for bevy_ui
-
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…
-
mevy_ecs_syntax
token handling for mevy_ecs!
-
playdate-sys
Low-level Playdate API bindings
-
dark_iron_ecs
Entity Component System library for Rust
-
simple-game-engine
A minimal game engine inspired by the OLC Pixel Game Engine
-
chiploxide
(todo) mystery, challenges, games, an ide 👁️🗨️
-
prongs
Input handling schema written in rust. Backend agnostic, provides serializability, assignment and unified interface for working with inputs. Keyboard, mouse and controllers supported.
-
ggsdk
that exports several types related to game development
-
bevy_mod_pies_spacetraders_api
SpaceTraders API implemented for Bevy the game engine
-
usi
handle type-safe communication with USI-compatible shogi engines
-
gdnative-async
Runtime async support for godot-rust
-
avian_smart_damping_plugin
A plugin for Avian and Bevy engines that implements a velocity damping system based on the properties of bodies and their projections
-
h_mat
A type-safe heterogenous matrix type
-
bevy_prefs_lite
preferences system for Bevy
-
bevy_heightmap
Create meshes from heightmap PNGs in the Bevy game engine
-
zara
Zara survival engine
-
coffee
An opinionated 2D game engine focused on simplicity, explicitness, and type-safety
-
bevy_flurx_api
api plugins for bevy_webview_wry
-
adi
Ultra-portable hardware interface for platform-agnostic applications
-
bevy_mod_chroma
A plugin for the Bevy game engine to allow control of Razer Chroma devices
-
bevy_blur_regions_fork
A Bevy plugin to selectively blur regions of the screen
-
modulator
A trait for abstracted, decoupled modulation sources
-
crayon
A small, portable and extensible game framework
-
krait
A game engine that I'm working on
-
fluffl
A cross-platform multimedia layer that exposes opengl,sockets,and audio utilities for desktop and browser
-
wuestite
2D game engine written in rust
-
bevy_fix_cursor_unlock_web
A tiny plugin that fixes Bevy not reporting when the cursor is unlocked on web
-
bevy_serialport
Async serial port plugin for Bevy game engine with enhanced error handling and convenience APIs
-
bevy_ui_bits
A mingy and opinionated collection of UI components for Bevy
-
bevy_svg_map
load SVG to bevy, adding properties based on the style
-
gl-from-raw-window-handle
creating an OpenGL context from a RawWindowHandle
-
bevy-web-resizer
Automatically resize your Bevy app on the web (wasm) to the size of the browser window
-
extol_sprite_layer
Explicitly-defined sprite layers for Bevy, including automatic y-sorting
-
pyxel-wrapper
Python extension module for Pyxel, a retro game engine for Python
-
nwn_nasher_types
parse and de/serialize the files from the nwn community tool, nasher
-
bevy_ios_alerts
Bevy plugin to request ios native UIAlert popups
-
re_chunk
A chunk of Rerun data, encoded using Arrow. Used for logging, transport, storage and compute.
-
tokyodoves
efficient board of Tokyo Doves and associated toolkits
-
maikor-vm-core
VM for playing Maikor games
-
type_ulid
Trait for associating ULIDs with Rust types
-
wow_spells
Spell definitions for World of Warcraft game servers
-
macademia
A realtime application/game engine written in rust
-
mask_system_lib
(bevy_mask_system)A library for system architecture that utilizes functional programming principles to organize code. It primarily uses mask-based generics to structure systems.
-
ggbasm
Generating Gameboy Assembler
-
bitmap7800
a companion tool of cc7800 for generating C code for bitmaps
-
bevy_vrm
Bevy plugin for loading VRM avatars
-
beetmash
The number one bevy scene registry
-
bevy_text_mesh
A bevy 3D text mesh generator for displaying text
-
bevy_blender
Bevy library that allows you to use assets created in Blender directly from the .blend file
-
lunex_engine
not inteded to be used standalone. It is a dependency of Bevy_Lunex
-
unity-native-plugin-sys
-
bevy_skybox
A skybox from an image for bevyengine.org
-
image-atlas
A texture atlas generator for generic purpose
-
bevy_cleancut
Random utility stuff for bevy for my personal use. You're welcome to use it, too, if you like.
-
magma_windowing
Part of the Magma-API, which is the API of the Magma3D game engine. This is responsable for handling windows.
-
rsanim
A basic state machine for managing sprite animations
-
include-wgsl-oil
Includes a WGSL file with the
naga-oilpreprocessor -
aery
Non-fragmenting ZST relations for Bevy
-
bevy-sph
A Smoothed Particle Hydrodynamics (SPH) simulation using Bevy
-
generational_array
A small package to handle generational arrays and prevent the ABA problem while reusing unused space
-
lueur
Shadowy game and graphics library for Rust
-
ca-formats
Parsing pattern files for Conway's Game of Life
-
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
-
ron_asset_manager
A dead simple crate to manage Ron based assets which depend on other assets
-
cogs-gamedev
Common, Obnoxious Game Stuff. Contains a bunch of useful boilerplate for writing games.
-
bevy-nest
🪹 A telnet plugin for getting MUDdy in Bevy
-
gridit
2D grid library utilizing the fun of iterators
-
amethyst_physics
The Amethyst Physics engine interface
-
hill_vacuum_shared
shared utilities among the other HillVacuum libraries
-
discord_game_sdk
Safe wrapper for the Discord Game SDK
-
bevy_system_graph
creating strictly ordered execution graphs of systems for the Bevy game engine
-
regecs
Rust Extended Generic ECS (REGECS)
-
olc_pixel_game_engine
Rust bindings for olcPixelGameEngine
-
bevy_fsl_box_frame
A gizmo for manipulating an OBB via 3D picking
-
navmesh
NavNet, NavGrid, NavFreeGrid and NavIslands navigation system
-
bevy_ios_impact
allows using ios ImpactFeedback API to generate haptic device vibrations
-
replace_ident_in_expr
Replaces target ident with given ident in an expr
-
catgirl-engine-utils
catgirl-engine crate
-
world-map-gen
Command line tool and library to generate random game world maps for both Rust and WebAssembly
-
bevy_sparse_tilemap
A Tilemap crate for the Bevy game engine with a focus on large map sizes and ECS sparse maps
-
bevy_text_animation
text animation library for Bevy
-
gba_save
Tools for interacting with backup media on Game Boy Advance cartridges
-
cube-lib
魔方 核心库
-
castle-core
CastleCore - Core engine for Altenstein (and same projects)
-
icosphere
Subdivided icosahedrons for rendering and meshing, both sparse and tightly packed
-
bevy_cells
Bevy library for working with entities in grids
-
chuot-packer
2D texture packing for the Chuột game engine
-
bevy_resolution
An easy to use convienence crate for dealing with resolutions in Bevy
-
mdbook_lad_preprocessor
Language Agnostic Declaration (LAD) file format for the bevy_mod_scripting crate
-
bevy_skybox_cubemap
Cubemap-based Skyboxes for Bevy Engine
-
ready-paint
schema using wgpu and winit
-
sculk
handling various data found in Minecraft's NBT files
-
gbfs
reading gameboy filesystem archives, a format commonly used in GBA homebrew games
-
distill
Asset framework for game engines & editor suites
-
bevy_bulletml
BulletML library in Rust with Bevy game engine suppor
-
game4all/vx_bevy
🧊 Voxel engine prototype made with the bevy game engine. Serves as a playground for experimenting with voxels, terrain generation, and bevy.
-
ottr
A highly parallel game engine
-
fast-tak
abstract strategy board game Tak
-
curseofrust-msg
Curseofwar messaging protocol implementation
-
bevy_console_parser
console command parser for bevy_console
-
ascending_camera
A basic camera solution for Rendering
-
bevy_retrograde
Pixel-Perfect, 2D Renderer and plugins for Bevy that Seamlessly Targets Desktop and Web
-
bevy_sparse_grid_2d
Wrapper around a 2d hash map made for collision broadphase
-
re_math
An opinionated game math library built on top the excellent glam
-
dmsdk
Rust-friendly wrappers around the Defold dmSDK
-
clocked
A collection of tools for synchronizing asynchronous audio streams
-
arche-tape
archetypal ECS
-
gerg_ui
A little wrapper I've written for creating UI screens from files for the BevyEngine
-
bevy_auto_system_macro
A macro for making bevy system queries more convenient
-
spin_sleep_util
Utils using spin_sleep
-
bevy_auto_timer
Bevy plugin for convenent timer
-
bevy-egui-notify
notifications library for EGUI, in the bevy system
-
double_dot_macro
Macros for the Double-Dot crate ecosystem
-
tttm
Tic Tac Toe game with a Menace AI
-
wecs
ECS lib for general use
-
bevy_physimple
2d physics engine for bevy based on physme
-
coord_2d
A general purpose 2d coordinate
-
bevy_serialization_core
contains the plugins/systems that bevy_serializations_extras relies on, + some misc wrappers
-
bevy_more_shapes
Bevy engine plugin that adds additional shapes to the existing collection of procedurally generated geometry
-
entropy-base
entropy-game shared library
-
bevy_gltf_kun
Bevy glTF plugin using gltf_kun
-
bevy_mod_opacity
Hierarchical opacity for bevy
-
ico_memory
Experimental custom memory manager and handle-based resource manager
-
bevy_aseprite_reader
Aseprite reader
-
rust_game_engine_ecs
Rust Game Engine ECS
-
salva2d
2-dimensional particle-based fluid dynamics in Rust
-
kayak_ui
A UI library built using the bevy game engine!
-
hexga_engine
Hexga Engine using MiniQuad
-
gaviota-sys
Low level bindings for libgtb, a library for Gaviota tablebase probing
-
scene-graph
a fast scene-graph for games and animation
-
bbecs_tutorial
An ECS library made for a tutorial
-
bevy_camera_extras
containing a collection of utilities to making working with cameras in bevy easier
-
tego
loading Tiled maps
-
blackjack
popular casino card game Blackjack
-
poker
speedy poker hand evaluation
-
ombre
Shadowy game and graphics library for Rust
-
bevy_webview
Rapidly iterate and build Bevy UI's with existing web-based technologies
-
bevy-discord-presence
Discord presence plugin for the Bevy game engine
-
bevy_dexterous_developer_library
A modular hot reload system for rust
-
bevy_webview_core
webview's core logic for bevy_webview_projects
-
casino_cards
that provides a deck of playing cards that can be used for various card games
-
rscenes
Scenes manager for Raylib
-
a2s
Source A2S query
-
bevy_parallaxation2d
providing simple 2D parallax layers in Bevy
-
moore-neighborhood
Calculates Moore neighborhoods (8-connected) for arbitrary ranges and dimensions
-
minefield
abstract layer for mine sweeper by Rust
-
bevy_egui_ime
plugin that supports Japanese input with bevy_egui
-
rafx-api
Rendering framework built on an extensible asset pipeline
-
vleue_navigator
Navmesh plugin for Bevy
-
fabulist-core
A branching narrative engine
-
bevy_impulse
Reactive programming and workflow execution for bevy
-
bevy_splash_screen
A plugin for bevy which allows you to create screens to show the brands and development teams behind your amazing game
-
bevy_modloader
allowing you to load and unload Bevy mods
-
lumenpyx
A 2D pixel art renderer with realistic lighting
-
beet_flow
An ECS control flow library
-
bevy_replicon_repair
Extends bevy_replicon with client-state repair for reconnects
-
tetrice
core functions of Tetris
-
bevy_zeroverse_ffi
bevy zeroverse ffi library
-
bevy_ui_inspector
inspecting bevy ui
-
bevy-codex
A manager for menus and huds with the bevy game engine
-
bevy_consumable_event
add events to Bevy that can be consumed
-
bevy_lospec
Asset loader plugin for Bevy that adds support for lospec color palettes
-
perovskite_game_api
Multiplayer voxel game written in Rust - default game content + plugin API
-
pixel-handler
Wrapper for the ggez game engine crate
-
rhusics
Physics library for use with
specs -
ggegui
egui for ggez
-
bevy_veilid
Build turn-based p2p games with Veilid
-
bevy-debug-text-overlay
A convenient on-screen message print macro for bevy
-
bevy_pixel_camera
pixel-perfect camera plugin for Bevy, suitable for pixel-art
-
bevy_remote_inspector
A remote inspector for Bevy game engine, allowing you to inspect and modify entities in real-time
-
lib-hearts
Basic Implementation of the hearts card game
-
bevy_yarnspinner_example_dialogue_view
Example dialog view for Bevy Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
geo-bevy
Generate Bevy meshes from
geotypes -
chess-engine
A dependency-free chess engine library built to run anywhere
-
perft
Chess perft tools, for use with chess-oxide library
-
valve-rcon
Valve's RCON in Rust
-
playdate-system
High-level System API built on-top of Playdate API
-
byond
interfacing with the BYOND game engine
-
bufferbuffer
Double Buffer design pattern from 'Game Programming Patterns' by Robert Nystrom
-
rovella
A game library that, at present, only consists of a windowing and events wrapper
-
obfuscate-integer
may stop most Cheat Engine (and other variants) program scanning for the relative address, and thus stop further modification
-
crabchess
Chess API
-
bevy_easy_portals
Bevy plugin for easy-to-use portals
-
obel
A refreshingly simple data-driven game engine and app framework
-
amethyst/space-menace
An action 2D platformer made with Amethyst game engine
-
box2d-rs
Port of Box2d to Rust
-
scion
Game making library on top of wgpu, winit, hecs
-
pobsd-parser
Simplistic parser for the PlayOnBSD Database
-
bevy_icon_creator
A plugin to automatically create Icons from entities/models in bevy
-
tarmac
Resource compiler and asset manager for Roblox projects
-
bevy_tiled_prototype
A plugin for rendering tiled maps
-
vigier
Lightweight game library
-
dentimoer-cli
small cli tool for dentimoer
-
bevy_pxtxt
Create fonts and render text in bevy based on a bitmap source image
-
bevy_ui_styled
function that let’s you define a bevy_ui
Stylecomponent withtailwindcssinspired syntax -
wutengine
A modern game engine
-
nimlib
Nim games: calculate nimbers and possible moves
-
libsmallworld
behind the "smallworld" binary crate
-
bscore-lib
bowling score library for C (written in Rust)
-
Clig
A CLI Game engine to make games in CLI
-
nphysics_testbed3d
Testbed for the 3-dimensional physics engine in Rust
-
limnus
game engine core
-
bevy_sepax2d
Plugins and helpful methods for using sepax2d with Bevy for 2d overlap detection and collision resolution
-
lacking
A game engine/framework port from Go
-
unity_native
A Rustified wrapper around the Unity Native Plugin API
-
devotee-backend-softbuffer
Softbuffer-based backend for devotee visualization engine
-
ryot_tiled
Supports tile-based game development, providing tools for drawing and managing tilesets and tiled maps
-
bevy_nfws
A no-frills websocket client library for bevy, native and wasm
-
jelly_ecs
but functional ECS
-
ps2logo
PS2 Logo Decryptor
-
siiir-bevy_fancy_cursor
Facilitates creating custom cursor in bevy-based app. Uses bevy’s
ImageBundleto replace the original cursor with moving UI element. -
zero_ecs
Entity Component System (ECS), using only zero-cost abstractions
-
bevy_scroller
Scroller plugin for Bevy
-
zvxryb-broadphase
A broadphase collision detection library
-
trs_24
An OpenGL-Powered Game Engine (OpenGL 2.0+)
-
unrust-codegen
The csharp codegenerator used by unrust
-
wolfengine
Wolf is a set of modules for realtime rendering, realtime streaming and game developing
-
ivy-collision
3D collision crate for Ivy
-
bevy_asky
question-and-answer UI middleware for Bevy
-
cob_sickle_math
Math dependencies for sickle_ui
-
ugli-raw
Game ENGine
-
bevy-wasm-tasks
integration of WASM tasks into a Bevy app for background processing
-
rust_game_engine_physics
Rust Game Engine Physics
-
bevy_2d_menu_mask_transition
A Bevy plugin for creating smooth menu transitions with customizable masks
-
libfar
interacting with FAR archives
-
bva_cli
Bevy Vach Assets CLI
-
bitstackchess
A bitboard‐based chess game engine with 10 × u128 move history
-
libliquidfun-sys
A thin Rust ffi wrapper on top of Box2D and LiquidFun. Built using autocxx.
-
seeded_dice_roller
A dice roller using a seed to give deterministic results
-
wolf_engine
A game framework with a focus on flexibility and ease of use
-
input-actions
An input system for binding PC & Gamepad inputs to application actions
-
bevy_mod_component_mirror
A bevy plugin to mirror components
-
bevy_yarnspinner
Bevy plugin for Yarn Spinner for Rust, friendly tool for writing game dialogue
-
paddle
2D Game Engine for Rust on the Web
-
frame_counter
frame counter and limiter
-
bevy_keith
2D graphics library for the Bevy game engine
-
i_mesh
Mesh generation library
-
ndlife
An infinite n-dimensional game of life
-
swamp-script-eval
interpreter for swamp script
-
naia-bevy-server
faciliate naia_server & Bevy interop
-
shulkerscript-cli
Command line tool to compile Shulkerscript projects
-
aeronet_channel
In-memory MPSC channel IO layer implementation for
aeronet -
mevy_ui_syntax
token handling for mevy_ui!
-
bevy_screen_diags
An on-screen FPS display for bevyengine.org
-
riichi
Japanese Riichi Mahjong game engine
-
bevy_fake_interior
Fake interior material for Bevy
-
epic-mickey-lib-rs
modding files for Epic Mickey (2)
-
mcvm_net
Various network APIs for MCVM
-
oxygen_suite
Oxygen Suite is a set of tools made with the Oxygen Game Engine to make assets
-
kratka
Grid essentials to build upon for the Bevy engine (DRAFT)
-
steam-cdn
Steam CDN
-
kira_framework
OneBot 11 based on the ECS architecture
-
bevy_child_window
Allows you to create an embed child window in Bevy
-
keeshond_treats
Easy building blocks for Keeshond so you can start making your games sooner
-
pleco
A blazingly-fast chess library
-
mewo
Lightweight ECS
-
auto-traffic-control
A video game for programmers about air traffic control
-
bevy_rmesh
A Bevy extension for RMesh loading
-
bmf-parser
read BMFont binary files
-
bevoids
A bevy plugin that aims to make boids easy to add to your game, without comprimising in control
-
zzchess
一个上传Crate的测试
-
bevy_interleave_interface
interface for e2e packed to planar bind groups
-
bevy_animation_graph
Animation graph library for the Bevy game engine
-
rustygba
GBA game development library, based on the "gba" crate
-
sophon
a game framework,support micro service
-
smecs
Dependency free ECS
-
luminol-data
Luminol's RPG Maker data structures
-
gdnative-doc-cli
Command line utility for gdnative-doc
-
bevy-gotrue
supabase auth for bevy apps
-
roq-dec
A minimal crate for decoding ROQ video streams
-
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.
-
jonmo
Bevy-native functional reactive signals
-
bevy_seedling
A sprouting integration of the Firewheel audio engine
-
ozz-animation-rs
runtime library for ozz-animation with cross-platform deterministic
-
kurinji
Input map for bevy
-
tiny-game-loop
Basis for a framerate-independent game loop. Only contains the calculations, so you could arrange the loop itself however you want.
-
bevy_docs_extension_demo
testing rustdoc extensions for Bevy
-
bevy_surreal
A Bevy plugin for SurrealDB integration. WIP not quite ready
-
monte_carlo
Preforms Monte-carlo tree search
-
bbggez
functions by the Brooks Builds community for the Rust game engine GGEZ
-
bevy_shader_graph
Shader graph for Bevy
-
bvh
A fast BVH using SAH
-
darkforge
Dark Forge is a library and extension for Godot engine that implements the Blades in the Dark SRD by One Seven Design
-
bevy_window_icon
Window icons in Bevy
-
charred-path
Component-based Bevy plugin for tracking path and homotopy data for moving objects
-
bones_schema
runtime reflection system designed for scripting
-
vulk
Vulkan bindings for Rust, except only the bleeding edge features
-
cargo-pixel
2d pixel art game engine & rapid prototype tools support terminal,sdl2 and web
-
bobox214/kataster
A beginner-friendly single screen space shooter developed in Rust with 'bevy'
-
thephet/bevyroguelike
Roguelike game using Rust and the Bevy engine
-
auburn
Fast and simple physics library
-
bevy_crossterm
Develop terminal games with crossterm and Bevy
-
libktx-sys
Rust bindings for libktx
-
gdengine
Game design document creation tool
-
small-card-deck
card deck library
-
fndg
An unchained map game where you battle for resources while building your nation up
-
moonshine-tag
Cheap, fast, mostly unique identifiers designed for Bevy
-
bevy-hikari
Realtime Path Tracer for the Bevy Engine
-
teenygame
A real simple multiplatform game framework for Rust
-
bevy_health_system
A quick and easy way to add a health system to any entity of your bevy game
-
fyrox-project-manager
Project manager for Fyrox engine
-
bevy_gizmos
gizmos for Bevy Engine
-
gerrymander
Push-down state automata for games
-
bevy_assets_bundler
Assets Bundler for bevy, with content encryption support
-
buri
A game engine
-
gfx_smaa
post process antialiasing using SMAA
-
overworld
Metapackage library for adding game systems useful for incremental, RPG, and management games
-
mythoji
A minimal Rust crate that helps identify and display fantasy appropriate emojis
-
springy
Stable springs for game development usecases
-
livesplit-auto-splitting
that provides a runtime for running auto splitters that can control a speedrun timer. These auto splitters are provided as WebAssembly modules.
-
team-plover/warlocks-gambit
The Bevy Jam 1 Team Plover game submission
-
bevy_scene_postprocess
Bevy that provides a way to postprocess scenes after loading them
-
chess-move-gen
Fast chess move generation library. Uses SIMD for fast sliding piece move generation
-
iyes_scene_tools
Extra helpers for working with Bevy Scenes
-
moonshine-object
Bevy Entities are nice. Objects are better!
-
bevy_hui_widgets
A collection of bevy components and systems to build widgets with
bevy_hui -
pabitell-lib
Interactive storytelling - core library
-
raylib-light
raylib bindings
-
seldom_fn_plugin
Allows using Rust functions in place of Bevy plugins
-
bevy_ghx_proc_gen
Bevy plugins for 2D & 3D procedural generation with WFC/Model synthesis
-
spirv-layout
SPIRV reflection utility for deriving Vulkan DescriptorSetLayouts
-
bevy-aabb-instancing-011
Render millions of AABB instances in Bevy
-
ra2-pal
Parser for Red Alert 2 palette files (*.pal)
-
rival
A framework for creating computer players for turn-based games
-
mc_schem
read, create, modify and write various Minecraft schematic files
-
ABC_Game_Engine
fast, and flexible Game Engine written in Rust, with simplicity in mind
-
otter-nodejs-tests
Otter game system; JavaScript out-of-browser test support
-
bevy_flair_style
Bevy UI styling using CSS
-
brick_bird
A colorful Flappy Bird clone written in Rust. Cross platform. Has own physic engine. Parallel.
-
rg3d-ui
Extendable UI library
-
bevy_gyroscope
A Bevy plugin that provides gyroscope functionality
-
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.
-
enco
entity-component library (not an ECS library!) for small projects
-
kakistocracy
A pile of vaguely gamedev related code, governed by its least suitable and/or most unscrupulous programmers
-
pagurus_tui
run Pagurus games on a terminal
-
bevy_sun_gizmo
gizmo for directional lights in Bevy
-
bevy_anyhow_alert
Easy system error handling with Bevy; let your systems return
Result! -
monstermaker_core
Core types for the Monster Maker ecosystem
-
bevy_easy_vec_ui
Easy Vec to UI display system for bevy. Options for display on left or right half of display.
-
quad_hexga_engine
Hexga Game Engine using MiniQuad
-
graphite_command
Command parsing and dispatch framework for the graphite_minecraft project
-
smesh
A fast and ergonomic surface-mesh/halfedge-mesh implementation and polygon mesh manipulation library based on pmp
-
forky_bevy
Rust Utilities
-
notation_guitar
Fun notation - definition for guitar
-
theobserver
read pen pressure using evdev
-
bevy_webgl2
A webgl2 wasm32 render backend for Bevy Engine
-
bevy_incandescent
A 2d lighting crate for bevy
-
ramirezmike/not_snake
A snake-inspired game made in Rust using the Bevy game engine
-
gm-ffi
an interface between GameMaker and Rust
-
bevy_mesh_terrain
ergonomic heightmap terrain plugin for Bevy game engine
-
heavyli_engine
A game engine based on 'OpenGL'
-
rrise
binding for Wwise
-
bevy_mod_stylebuilder
A set of fluent builder utilities for Bevy UI styles
-
bevy_cosmic_edit
Bevy cosmic-text multiline text input
-
ck3save
Ergonomically work with all CK3 saves (regular and ironman)
-
savesys
Variable-based save management system
-
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…
-
chargrid_ggez
Graphical chargrid context which renders with ggez
-
curseofrust-cli-parser
CLI arguments parser for curseofrust
-
clige-rs
CLI Game Engine - clige
-
bevy_capture
A Bevy plugin for capturing frames from a Bevy application
-
nest_lightmap
A plugin for Bevy w/Nest that interfaces lightmaps from The Lightmapper
-
bevy_testing
Testing library for bevy
-
mun_abi
Rust wrapper for the Mun ABI
-
bevygap_client_plugin
Plugin for bevy games for use with bevygap matchmaker and lightyear
-
game-grid
2D grid for prototyping games. Including easy parsing, indexing and iterators.
-
bracket-state-machine
State management library for bracket-lib terminal
-
korome
WIP game engine using glium
-
perovskite_core
Multiplayer voxel game written in Rust - Implementation details shared between client and server
-
tecs
TeaECS, a simple ECS
-
pistoncore-event_loop
A Piston event loop for games and interactive applications
-
neos
NeosVR's API in rust
-
fps_clock
making your game loop run at the correct FPS
-
billy
A small ECS libary written in Rust
-
morph3d
assimp alternative (obj, gltf & glb is supported). DAE, Stl and Usdz support is comming soon.
-
cute-dnd-dice
roll dices
-
edger_bevy
edger.dev shared logic for bevy applications and libraries
-
godot-rust-cli
easy way to use Rust with your Godot project
-
bevy_octopus
ECS based networking library for Bevy
-
bevy-either
A Bevy crate allowing macro-built WorldQueries matching over one of many other WorldQueries
-
componentile
Kind of like a minimal, tile-based ECS
-
some_bevy_tools
A collection of tools which can be used in the Bevy Engine
-
morkovmap
A data-driven, Markov Chain-based tilemap generator library and app
-
my-ecs
An Entity Component System (ECS) library
-
rusticify
App for brainstorming & sharing ideas 🦀 Learning Project
-
bevy_web_file_drop
Bevy plugin adding better support for drag and drop files in the web
-
keeshond
A fast and fun 2D game engine for Rust
-
bevy-tnua-avian3d
Avian 3D integration for bevy-tnua
-
leafwing_input_playback
Input recording and mocking functionality for the Bevy game engine
-
tupdate
Tejat Updater
-
bevy_material_wizard
A material replacement utility for bevy
-
bevy_picking_tilemap
bevy_mod_picking support for bevy_ecs_tilemap
-
omt
A set of tiny tools mostly used for game development. A Texture atlas packer, a font converter, a pakfile creator.
-
ui4
A reactive vdom-free ui library for the bevy game engine
-
rust_game_engine_ui
Rust Game Engine UI
-
game_clock
clock for game (engines) that is simple to use and efficient
-
bevy_scoreboard
A very simple scoreboard plugin for Bevy
-
lmbr_build
Amazon Lumberyard (unofficial)
-
black_grimoire
game engine
-
bevy_ghx_utils
shared bevy utilities
-
guimcaballero/bevy_rhythm
A small rhythm game implemented in Bevy, with an accompanying tutorial
-
definitive
final vector & matrix library for Rust
-
dialogos
A super simple dialogue system for Rust
-
deckofcards
An API to implement a deck of cards
-
bevy_mod_wanderlust
A character controller library for Bevy Engine
-
buzzy
browser
-
bevy_editor_cam
A camera controller for editors and CAD
-
unrust
side of the unity package to work with rust + bevy in unity!
-
corrosive-ecs-core-macro
Macros for Core Functionality of Corrosive Engine
-
limnus-message
message container
-
uobors_cli
Unleash OpenBOR modding in Rust
-
rantz_camera2d
A 2D camera plugin for Bevy, inspired by the Love2D camera plugin - STALKER-X
-
unreal_helpers
Tools for making and loading Unreal Engine Mods
-
glicko_2
Glicko2 is an iterative algorithm for ranking opponents or teams in 1v1 games
-
dces
DCES entity component system
-
bevy_gltf_save_load
Save & load your bevy games
-
dfhack-proto-srcs
Download and extract DFHack protobuf files from source
-
game_of_life_bevy
Conway's Game of Life in bevy
-
billow
Wave Function Collapse implementation in Rust
-
shax
A work-in-progress chess engine
-
gn-matchmaking-state-types
Component for shared state-management-types in the game-night backend
-
irrgarten
Small and easy to use library to generate mazes for games
-
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.
-
prime-forge
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
bevy_toast
A bevy plugin to easily show toast notifications to the player
-
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
-
cubi_vectors
Vector library
-
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.
-
bevy-translation-table
A super basic translation table system for bevy supporting generic data, CSV, and ODS
-
voxel_engine
Public API for the octo voxel game engine
-
corrosion
A Magic: The Gathering rules engine
-
ecs_girvel_common
Common types for ecs_rs
-
kiwi-ecs
A performant, small and versatile entity component system
-
gameloop
deWiTTERS game loop
-
goguryeo_core
Core implementations for Goguryeo online
-
hnefa
An engine for tafl-style games
-
rect_packer
A rectangle packing library. Heavily tested with random data to ensure that it always produces correct result.
-
wad
binaries for reading WAD files compatible with the Doom game engine
-
kifuwarabe_tic_tac_toe
A small example before developing computer chess and computer shogi. Come see the repository.
-
opensimplex2
Port of OpenSimplex2
-
ecs_rust
ECS in Rust
-
bevy_double_res
Straightforward double buffering implementation for bevy resources
-
bevy_trauma_shake
A plugin for shaking 2d cameras
-
bevy_mod_sysfail
Decorate your bevy system with the sysfail macro attribute to handle failure
-
bevy-overlay-plugin
Bevy plugin to render CEF overlays on top of games
-
bevy-autoplay
Automated integration testing based on recorded play-testing sessions
-
aeronet_transport
Transport layer implementation for
aeronet -
bavy
This package may become something, or it may remain nothing. Bavy is not Bevy, that is for certain.
-
bevy_mod_transform2d
A 2D Transform component for The Bevy game-engine
-
arduboy-rust
used in Rust for Arduboy to program Arduboy games in Rust
-
bevy_prototype_networking_laminar
prototype of a networking crate for bevy. This create provides a low-level networking plugin built on top of laminar.
-
bevy-tick-timers
Tick based timers for Bevy
-
arimaa_engine_step
A step based engine for the board game Arimaa
-
libecs
Rust ecs design pattern
-
bevy_flair_css_parser
Bevy UI styling using CSS
-
aamp
Nintendo parameter archive (AAMP) files
-
simbelmyne-uci
used by the Simbelmyne chess engine for interfacing over the UCI protocol
-
firewheel
Flexible, high-performance, and libre audio engine for games (WIP)
-
convchain
Bitmap generation from a single example with convolutions and MCMC
-
bevy_ios_notifications
Bevy plugin to interact with iOS Notifications API
-
slot_machine
Bluejay Bonanza Slot Machine
-
shogi_official_kifu
The official notation of shogi moves
-
rantz_suite
A combined suite of tools provided by Rantz for use with the Bevy game engine
-
saft-sdf
Signed distance field function library
-
bevyinit
An easy way to create projects with Bevy Engine
-
bevy_fortress
My personal helper library for Bevy
-
bevy_picking_state_machine
A global state machine for working with
bevy_picking -
steam-language-gen
Generate Rust bindings to Steam enums and messages
-
bevy_trackpad_haptic
A bevy plugin for triggering trackpad haptic feedback on a mac
-
hex-spiral
A single-coordinate 2D hex grid
-
timeline_rs
timeline library for Rust
-
vigilant_lamp
Multi-target game engine / graphics library
-
gdnative-bindings
The Godot game engine's automatcally generated bindings to Godot classes
-
bevy_openai
event-driven plugin for Bevy that provides convenient access to the OpenAI API
-
ambient_guest_bridge
Ambient runtime that allows code to target either native host code or the API exposed to guest code
-
act2
Act 2 is a simple engine for making text-based adventure games using JSON
-
clauser
parsing and deserializing Clausewitz files
-
inexor-rgf-model-http
Inexor - Reactive Graph Flow - Model - HTTP
-
bevy_follow_path
components and systems that enable entities to follow a path
-
thinkofname/univercity
Source code of the game Univercity: https://store.steampowered.com/app/808160/UniverCity/
-
bevy_combat
A sci-fi battle simulation implemented in the bevy engine
-
bevy-where-was-i
A plugin for Bevy that saves and restores your camera position
-
dip
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
bevy_oxr
Community crate for OpenXR in Bevy
-
bevy_ballistic
Bevy math functions to calculate projectile launch angles to hit a specific target
-
mod_plugins_resources
Reduce plugin boilerplate in the Bevy game engine
-
nd_vector
[WIP] Lengthen! Shrink! Iterate! Scale! Twist and turn to your imagination along any dimension on a vector!
-
micro_bevy_web_utils
patching various missing parts from Bevy web/touch support
-
mun_diagnostics
in-depth diagnostic information for compiler errors
-
maikklein/unreal-ffi
Rust integration for Unreal Engine 5
-
are_we_touching
Collision Detection library
-
ogsolve
The program for solving octal games
-
roasted-core
Core library for Roasted game engine
-
catgirl-engine-server
Server side part of the catgirl-engine crate
-
morristown
working with https://github.com/coding-horror/basic-computer-games
-
inside-baseball
Modding tools for Backyard Baseball 2001
-
evoke
Powerful netcode for edict based game engines
-
libfj
An unofficial collection of APIs used in FreeJam games and mods
-
dentimoer
this is dentimoer
-
bevy_puffin
Integration layer between Bevy, puffin and tracing
-
test_lulu
A fun test_lulu game
-
dragon_blade
A transpiler from Rust to Overwatch Workshop
-
edict-proc-lib
Powerful entity-component-system library
-
bevy_webcam_facial
Webcam AI face recognition plugin for bevy game engine
-
blenvy
Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side
-
bevy_fpc
First person controller plugin for the Bevy game-engine
-
devotee-backend-pixels
Pixels-based backend for devotee project
-
pocket-relay-mitm-server
Pocket Relay Redirector server used to proxy clients to the main server while logging traffic
-
ren
easy to use graphics library
-
steamworks-sys
raw bindings to the steamworks sdk
-
vertix
A cross-platform performant ECS game engine
-
ezinput
A powerful input-agnostic library targeting complete support to axis and button handling for the Bevy game engine
-
simple-cards
deck of cards library with some useful functions
-
limnus-audio-device
Opens an audio output device
-
rafx-framework
Rendering framework built on an extensible asset pipeline
-
bevy_webp_anim
Plugin for loading and playing animated webp images in bevy
-
lingon
A game engine mainly intended for use in game jams
-
blocky-net
creating Minecraft clients, enabling packet manipulation and automated interactions with Minecraft servers
-
vingt-et-un
A blackjack engine
-
houtamelo_utils_gdext
A collection of utilities shared between Houtamelo's GDExtension projects
-
firecore-battle
Pokemon battle simulation
-
dds-bridge-sys
Generated bindings to DDS, the double dummy solver for bridge
-
gameloop-timing
Timing utilities for gameloops & mainloops
-
stabilkon
Mesh builder for tile maps using using texture atlases
-
qubic_engine
qubic engine
-
psvr
interfacing with the PlayStation VR
-
ae-direction
handling directions (cardinal and ordinal). Intended for use in game development.
-
bevy_headless_render
A plugin for the bevy engine which enables headless rendering to an image for use in the main world
-
macroquad
easy to use graphics library
-
xplane
High-level interfaces to the X-Plane plugin SDK
-
xwebtransport
A common WebTransport interface for browser and native. Write once, run anywhere. Originally intended for use with bevy.
-
hexgame_rs
game Hex, a discrete full-information strategy game for two players
-
transvoxel-data
The tables necessary to implement the Transvoxel algorithm
-
uasset
Parsing of Unreal Engine asset files (uassets)
-
leaprs
Safe wrapper for the LeapC Ultraleap (Leap Motion) hand tracking device API
-
nate-engine
Fun High Level ECS Game Engine I Wrote
-
burrito
game development
-
ivy-window
GLFW window wrapper
-
olc-pge
A reimplementation of the olcPixelGameEngine in Rust
-
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.
-
planning
allowing the planning of minimal sequences of actions to achieve a goal state
-
bevy_vox_mesh
A bevy engine plugin for loading magica voxel files directly in bevy as usable meshes
-
gsa
Game development library modelled after an imaginary console
-
playt
game library for the terminal
-
bitshifter/bevy-physics-weekend
Game physics in one weekend with bevy
-
macroquad-canvas
Adds canvas functionality to Macroquad
-
tm-sys
FFI bindings for the machinery api
-
bevy-drpc
A bevy Discord RPC plugin
-
limnus-clock
clock management
-
bevy_rhai
An easy way to integrate Rhai with Bevy
-
cuicui_dsl
An easily-extensible macro to spawn things in bevy
-
unity
working with Unity projects
-
bevy_hammer_ui
Barebones ui widget plugin built for Bevy
-
bevy_mod_progress
Convenient, strongly-typed progress tracking
-
eu4save
Ergonomically work with all EU4 saves (ironman and multiplayer)
-
libchessticot
A chess library with engines
-
bevy_auto_plugin_nightly_shared
shared lib for bevy_auto_plugin that require nightly rust
-
ayaka-primitive
Primitive types for Ayaka
-
bevy_121
One-to-one relationships for Bevy ECS
-
bevy_dynamic_bundle
dynamic bundles for bevy
-
topaz
A tiny game engine
-
mighty-mancala
A Text User Interface Mancala Game
-
gdrust
interacting with gdnative-rust a little easier
-
bevy_mod_auto_exposure
An auto exposure plugin for Bevy
-
prints
Template entity blueprints for bevy
-
ggmath
optimized generic-graphics-math
-
treasury-api
API for treasury server
-
bevy_wry
A tauri-apps/wry integration with Bevy engine
-
unreal_asset
Unreal Engine 4/5 game asset serialization library
-
ggez-goodies
Various small useful add-ons for the ggez game framework
-
ultimate-ttt
Ultimate Tic Tac Toe - Game engine
-
bevy_starfield
A procedural night sky plugin for bevy
-
ldtk
reading the LDtk 2D tile map format
-
indeedee
Distribute iterated work over multiple frames
-
bevier
An interactive CLI to generate Games using the Bevy Game Engine
-
teki
Touhou-style shoot'em up
-
bevy_remote_stream
Remote streaming plugin for Bevy
-
pf_sandbox_lib
Data structures and helper code for PF Sandbox
-
thousand_birds_bevy_embedded_assets
A Bevy plugin to embed assets in your game
-
bevy_orbits
A bevy plugin for creating stable orbits, and calculating transfers between them
-
bevy_previous
Access previous values of components
-
hammerspace
A plugin for the loading and management of levels and scenes, and their physical properties
-
bevy_server_browser
Bevy game engine plugin for creating and searching discoverable servers on local networks
-
bevy_gltf_animation
Minimal animation setup for gltf files
-
bevy_ui_coords
Bevy UI coordinates
-
tts-external-api
External Editor API for Tabletop Simulator
-
bevy_fnplugins
A plugin for bevy that allows you to use functions as plugins
-
bracket-noise
Rust port of Auburn's amazing FastNoise library. Part of the bracket-lib family.
-
bevy_wasm_shared
Run WASM systems in Bevy
-
notch
A compact and fast library for managing Minecraft servers
-
bevy_nine_slice_ui
A nine slice/patch texture plugin for bevy ui nodes, works in wasm
-
thallium_ecs
The ECS for the thallium crate
-
rust-training-tool
A very simple game engine using egui. Made for a rust training session, do not use!
-
bevy_mod_reaction
Reactive components for Bevy
-
evalexpr
A powerful arithmetic and boolean expression evaluator
-
fts_gamemath
collection of crates that provide basic building blocks for 3d video game math
-
openlegends-client
OpenLegends Client Library
-
bevy_mod_spritesheet
Create TextureAtlasLayouts from common sprite sheet formats
-
bevy-tnua-rapier2d
Rapier 2D integration for bevy-tnua
-
bevy_mask_system
system architecture that utilizes functional programming principles to organize code. It primarily uses mask-based generics to structure systems.
-
cuicui_reflect_query
A bevy reflection addon to query world data from Reflect Components
-
bevy_easy_config
A Bevy plugin that allows you to easily define and instantiate config files
-
rezcraft
Minecraft like game written in rust using wgpu, supporting both native and wasm
-
bevy_spicy_networking
A spicy 🌶🌶🌶 and simple networking plugin for Bevy
-
bevy_enum_filter
Filter by enum variant in Bevy queries
-
dos-like-sys
Low-level bindings to dos-like
-
bevy_mod_chroma_request_lib
Request lib for bevy_mod_chroma
-
bevy_schedules_ext
A Bevy plugin for expanding the use of schedules
-
bevy_mod_raycast
Ray Casting for the Bevy Engine
-
bevy_wasm_scripting
Adds support for wasm/wat assets in Bevy, and enables easy scripting
-
bevy_u8_assets
Allows one to write u8 bytes of an asset with a fake file path to bevy
-
sweet_bevy
Bevy utilities
-
bevy_libgdx_atlas
Support loading
libgdx.atlasfiles (used for sprite sheets and such) as Bevy assets -
rpgn
parsing PGNs (Portable [Chess] Game Notation)
-
spritesheet_detector
analyze spritesheets and detect sprite dimensions and frame count
-
bevy_observed_utility
Ergonomic and Correct Utility AI for Bevy Engine
-
kusa_pixel
A pixel art painter for people who are sick of GUIs
-
bevy-realtime
bevy plugin for supabase realtime integration
-
bevy_animation_graph_editor
Animation graph editor for the Bevy game engine
-
doryen-fov
A pure rust library containing 2D field of view algorithms for roguelikes
-
obel_ast_map
Provides obel_ast_map
-
treasury-cli
Command Line Interface for treasury client
-
bevy_quill_overlays
Reactive, translucent overlays
-
arbor
A generic interface to the Monte Carlo Tree Search algorithm
-
bevy_mod_gizmos
Visual gizmos to aid with development and debugging in Bevy
-
bevy_query_service
that helps with querying components as a service in Bevy
-
celtic-names
A celtic name generator
-
retroboard
A chess retrograde move generator, suitable for endgame tablebase generation
-
swamp-examples
Examples for the swamp 2D game engine
-
bevy_color_blindness
Bevy plugin to simulate color blindness
-
rluau
High level luau bindings for Rust
-
vibha
text adventure live-loading
-
geng-ui
Game ENGine
-
mwbryant/monster_fighter
bevy game in a style similar to classic rpgs
-
bevy_verlet
Verlet physics implementation in bevy
-
gox
loading Goxel .gox files
-
bevy_submerge_ui
A ui plugin with tailwind like capabilities for bevy
-
pokemon-sprite-compression
dealing with compressed Pokemon sprites
-
notation_model
Fun notation - runtime models
-
hephae-render
Hephae's core rendering module
-
bevy_mod_try_system
An extension trait for Bevy systems that return Results
-
allegro_primitives-sys
Allegro 5 primitives addon Rust binding
-
mmo
Libraries for building scalable game servers
-
despero-hecs-schedule
shedulable systems and parallel execution for hecs
-
spirit_edit_core
spirit editor
-
bevy_rapier_collider_gen
generating bevy_rapier2d colliders, for bevy apps, from images with transparency
-
bevy_tile_atlas
A TextureAtlas builder for ordered tilesets
-
bsp
load BSP files efficiently - currently only works for Quake 3 BSP files. Fork of
quake3_loadercrate. -
swamp-code-gen-program
converts a Swamp program to swamp-vm opcodes
-
rokol
Rust bindings to Sokol
-
bevy_replicon_renet
Integration with renet for bevy_replicon
-
dexterous_developer_types
A modular hot reload system for rust
-
wolf_engine_input
A high-level input API
-
playdate-controls
High-level controls API built on-top of Playdate API
-
bevy_tiles
Bevy library for working with entities in grids
-
bevy_config_system
providing a way to handle dynamic configuration in Bevy
-
component_storage
pack components based on type in continous arrays
-
mrk-its/bevy-robbo
Port of mrk-its/rust-robbo to bevy
-
fontstash
wrapper of a forked version of fontstash
-
rekt-protocol-common
Common lib to use the rekt-protocol. See the crate homepage to check the protocol RFC.
-
bevy_health_bar
Bevy plugin to easily create progress bars, health bars, and more for UI
-
katharostech/arsenal_runtime
Blender game engine prototype written in Rust
-
wasm4fun-sound
Sound primitives and subsystems for WASM-4 fantasy console
-
slowchop_console
A Quake style console and log plugin for Bevy
-
ae-position
handling position on a 2D grid. Intended for use in game development.
-
emf-core-base-rs
Idiomatic Rust wrapper of the emf-core-base interface
-
u64-id
A tiny library providing a u64 backed id
-
victorem
UPD Game Server Framework
-
fps-controller
fps stabilizer for eventloop
-
aeronet_io
IO abstraction primitives for
aeronet -
rhusics-ecs
Physics library for use with
specs -
sickle_ui_scaffold
Scaffolding framework for sickle_ui
-
obel_scene
scene to organize game objects
-
mudbase
help make developing MUDs in Rust a breeze
-
lua-shared
Really simple wrapper around lua_shared(_srv) that tries not to be a total burden when interfacing with gmod's lua
-
rusty-chess-cli
command line chess game written in Rust
-
uobors_infrastructure_database_seaorm
Unleash OpenBOR modding in Rust
-
bevy_mod_scripting_functions
Necessary functionality for Lua support with bevy_mod_scripting
-
seldom_interop
Interoperability traits for Bevy components
-
kratka_ldtk
LDTK importing for kratka
-
hexmap
creating and working with hex-based tile maps
-
oxygen_core
Oxygen Core is the central part of the Oxygen Game Engine
-
overworld_demo_typegame
A typing game demo using the Overworld library
-
mevy_core_syntax
token handling for mevy_core!
-
bevy_retro_macros
macros used in Bevy Retro
-
podch
Game engine for the podch abstract board game
-
rusty-chess-gui
A gui for the chess engine
-
oxygengine-procedural
Procedural content generation module for Oxygengine
-
newport_log
Global logger package for Newport engine
-
engine-macros
Macros to the Let engine
-
pixel_engine_console
An extension for the pixel_engine game engine that add an in-game console
-
bottomless-pit
A very simple 2D rendering/game engine inspired by raylib
-
hivetuilib
abstracting turn based games
-
box_intersect_ze
Broad phase collision detection using Zomorodian and Edelsbrunner's hybrid algorithm (streamed segment trees with pruning and scanning)
-
voxel_engine_types
Public API for the octo voxel game engine
-
valence
A framework for building Minecraft servers in Rust
-
srcconsole
interact with the source engine console
-
kludgine-app
Application and Windowing for Kludgine
-
tiny_die
A tiny lib crate for tiny dice
-
tomb
A minimal crate that provides dice rolling mechanisms for games
-
planck_ecs
A tiny but very powerful ECS framework
-
riichi-elements
Building blocks of Japanese Riichi Mahjong
-
bevy_tweening_captured
Tweening animation plugin for the Bevy game engine
-
lpcg
A lib to generate character spritesheets based on LPC
-
tiled-json-rs
parse and interact with Tiled editor JSON files
-
gaclen
handling anything a game client needs to do
-
bevy_adventure
A framework for building adventure games in Bevy
-
dmastorage
High-performance I/O for Linux based on DMA Buffers
-
game-save-backuper
back up save data of some game server
-
moonshine-spawn
Collection of tools for spawning entities in Bevy
-
pixelate_mesh
Apply a pixelation effect to any Bevy mesh or scene without post-processing
-
catgirl-engine-client
Client side part of the catgirl-engine crate
-
modinfo_7dtd
Read/Write '7 Days to Die' ModInfo.xml files
-
pseudo_term
Window and graphical object-manager for making ASCII-art games
-
ff-particles
A fork of macroquad-particles with serde support
-
mc-launchermeta
providing types for the Minecraft Launcher Metadata API
-
gamesync_client
Client-side multiplayer game networking library
-
wgsl-minifier
A command-line tool for minifying WGSL shaders
-
go_core
Part of Griffsort game
-
bevy_gltf_components
Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side
-
kifuwarabe_connect_four
WIP. Connect-four AI. Currently, does not work.
-
geng-debug_overlay
Game ENGine
-
firecore-pokedex
A pokedex library
-
bevy_ambient_cg
Bevy Plugin for importing materials from https://ambientcg.com/
-
bevy_client_server_events
Simplified game networking
-
rouler
A container-like system for generating dice rolls
-
bevy_mod_picking
A modular picking plugin for Bevy
-
comfy-ldtk
LDTK editor support for the Comfy Engine
-
dodgy_3d
ORCA, a local collision avoidance algorithm for 3D
-
luminol-ui
Luminol's UI code
-
bevy_ghx_grid
Bevy plugins for 2D & 3D grids
-
bevy_asepritesheet
Allow use of animated exported asetprite sprite sheets in bevy game engine
-
mewo_ecs
Lightweight ECS
-
bevy-firebase-firestore
firebase firestore for the bevy game engine
-
lib_tictactoe_menace
Tic Tac Toe game with a Menace AI
-
swamp-vm-test
examples and tests on how to use the swamp vm with swamp
-
sprite_dicing
Cross-engine tool for lossless compression of sprite textures with identical areas
-
bevy_wasm_window_resize
Bevy helper crate that makes application canvas match window size
-
render_engine
A Metal-based 3D rendering engine for macOS
-
bevy_file_asset
bevy file asset plugin
-
bevy_spawn_observer
Add observers to your bundles
-
wutengine_opengl
The OpenGL backend for WutEngine
-
bevy_shape_draw
A shape drawing tool for Bevy
-
bbecs
ECS library for Brooks Builds projects made live on Twitch at https://twitch.tv/brookzerker
-
dexterous_developer_test_utils
A modular hot reload system for rust
-
lightyear_avian
Helper library to use Lightyear with Avian
-
bevy_heterogeneous_texture_atlas_loader
Load heterogenous texture atlases from a ron manifest
-
bevy_auto_scaling
Auto scale cameras to fit the window
-
bevy_xpbd_2d_interp
interpolation of bevy_xpbd rigidbodies
-
gamesense
SteelSeries GameSense™ client written in Rust
-
unrust-inbuilt
Inbuilt types common between unity and bevy used by unrust
-
helium
A collection of useful functionality for 2D game development
-
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!
-
ba2
working with the Bethesda archive file format
-
rmt2cc7800
a companion tool of cc7800 generating C code from RMT songs (Raster Music Tracker)
-
yml_dialog
A very light base structure to implement an Rust Dialog using YML (file) format
-
usi-run
A command line utility for running games between USI compliant Shogi engines
-
mctools
that contains some Minecraft tools
-
bevy_mod_check_filter
A module for improved ergonomics with Enabled-style marker components
-
wutengine_graphics
Graphics and rendering interfacing code for WutEngine
-
bevy_gpu_compute
Empowering anyone to leverage GPU-acceleration with as little barrier-to-entry as possible
-
i-cant-believe-its-not-bsn
Tools for spawning entity hierarchies in Bevy
-
gravitron_ecs
performant ECS for Gravitron
-
bevy_render_layers_manager
Manager for Bevy RenderLayers
-
nimble-assent
Authoritative state
-
bevy_minecraft
Minecraft servers using bevy
-
entity_store_code_gen
Code generator for game data store
-
bevy_utils
A collection of utils for Bevy Engine
-
gdvariants
Rust std library collections wrapper that implements the godot-rust variant traits
-
bevy_accelerometer
A Bevy plugin that provides accelerometer functionality
-
texture_bag
storage and loader for glium textures
-
bevy_wasm_touch_fix
For Bevy >=0.12, a plugin that fixes the issues of incorrect touch positions in wasm
-
lunara
A work-in-progress, postmodern game engine
-
bevy-lua-mod
Adds lua modding support to Bevy
-
bevy_h264
A primitive h264 player for Bevy
-
foxy_log
Common logging utilities for
foxy -
rust_fish_chess_engine
A chess engine and functionality built in Rust. Built for the intention of incorporating it into my Svelte chess project through WASM.
-
amethyst_lyon
Amethyst Lyon crate
-
bevy_fpc_sprint
Sprinting feature for
bevy_fpc -
resources
Safe store for one value of each type, with interior mutability
-
ionic_deckhandler
deck creation and card shuffling library
-
asciivation_duty_renderer
in-terminal 3d renderer for a game i was/am writing, but that may also be useful as a standalone library
-
limnus-wgpu-math
wgpu math types
-
bevy_b3d
A Bevy extension for B3D loading
-
voxy
Voxel engine for Bevy
-
ivy-physics
physics for the Ivy framework
-
recompose_core
Core crate of the
recomposecrate -
rrise-headers
A helper for Rrise, generating headers based on soundbank definition files
-
rose-graph
a small graph, not usable for most projects
-
bevy_osc
Send and receive OSC data to and from bevy and other programs or controllers
-
hotham-debug-server
debug tool for debugging Hotham applications
-
bevy_stroked_text
A Bevy plugin for stroked text rendering
-
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
-
bevy_toon_material
A toon shader in the style of Windwaker or Breath of the Wild
-
jeremychone-channel/invaders
game with the Bevy Engine
-
macroquad-virtual-joystick
joystick for macroquad games
-
jecs
but functional ECS
-
openlegends
Open Source, Multi-Player Card Game
-
mun_hir
high-level intermediate representation of Mun code
-
okizeme_utils
containing various utility types and functions for okizeme
-
aoaddons
creating addons for albion online game in multiple programing languages
-
reason-othello
An Othello library with a blazing fast bitboard
-
newport_imgui
Immediate Mode GUI for Newport
-
vbsp
Rust parser for valve bsp files
-
html_to_bevy
A procedural macro to generate Bevy UI code from HTML-like syntax
-
blua
bevy lua integration for doing systems in lua
-
yurei
a WIP high level wrapper around bevy_rapier3d created to remove some of the boilerplate while prototyping 3d platformers with bevy
-
gravitron_plugin
Gravitron Plugin
-
gravitron_hierarchy
Gravitron's ECS Hierarchy
-
bevy_editor_pls_default_windows
In-App editor tools for bevy apps
-
craballoc
Slab allocator with RAII
-
shard-ecs
The Shard Entity Component System
-
ira
A general-purpose, code-first game engine
-
mwbryant/bevy_survival_crafting_game
Don't Starve inspired game created to go along with live coding sessions on Youtube
-
valence_spatial
Spatial partitioning for entities in Valence
-
cuicui_layout
A layout algorithm for bevy and made to be understood by humans
-
gmath
math for graphics and games
-
bevy-avian-baseball-flight
Baseball flight simulation with Bevy and Avian
-
bevy-basic-ui
A small manager for menus and huds
-
glacier-texture
Read and write Glacier Texture files
-
dialga
Blueprint instantiator for Palkia
-
klaus_of_death
A game I am making for my friends with a doom-style renderer
-
yarnspinner_compiler
Compiler for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
rhyoea-common
Rhyoea is a Vulkan API bindings for Rust programming language. (Common modules)
-
overworld_incremental
Overworld Incremental Library - Tools for incremental games
-
palkia
Entity Component Message architecture a la Caves of Qud
-
pantheon
An opinionated WIP/Experimental 3D game engine
-
audionimbus-sys
Rust bindings for Steam Audio
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
crankit-image
An ergonomic image API for the playdate
-
pluto-servers
fetching Call of Duty server data from the Plutonium API
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
littlewing
A chess engine rated at 2050+ ELO, compatible with both UCI and XBoard protocols, with a nice CLI, and a documented library
-
bevy_2d_inverse_kinematics
A 2D inverse kinematics plugin for Bevy
-
minecraft-assets
Parsing Minecraft asset files and resource packs in Rust
-
bevy_other_world
Experimental subworlds plugin for Bevy
-
bevy_auto_update
Add automatic updating to your Bevy game
-
bevy_serialization_physics
adding physics wrappers for bevy_serialization_extras
-
simbelmyne-chess
A chess library that takes care of board representation and move generation, used by the Simbelmyne chess engine
-
bones3_core
The core functionality for the Bones Cubed plugin for Bevy
-
amethyst-imgui
imgui library for amethyst
-
ggez_ui
ui for ggez. No tutorial yet, but i might make one later
-
hoi4save
Ergonomically work with HOI4 saves
-
sungod
0-Dependency random numbers to brighten your day
-
wasm4fun-fmt
Formatting primitives for WASM-4 fantasy console
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
rafx-visibility
Rendering framework built on an extensible asset pipeline
-
edger_bevy_view
edger.dev view abstraction with common layout support
-
bevy_bundled_observers
Set observers on an entity from inside bundles
-
rusty_textui
creating simple text user interfaces, like text arcade games in the terminal
-
tiled_parse
Tiled tmx parser with nom
-
spritesheet-generator
A spritesheet generator library using the piston's texture_packer
-
bevy_render
rendering functionality for Bevy Engine
-
emf-core-base-rs-ffi
Rust wrapper of the emf-core-base interface
-
berdicles
Expressive CPU particle system for the bevy engine
-
bevy_retrograde_macros
macros used in Bevy Retrograde
-
namigator
Rust bindings for the namigator pathfinding library for World of Warcraft
-
hexga_engine_core
The Core the Hexga Game Engine, implementation free without RAII
-
treasury-server
Treasury server
-
rust_game_engine_core
Rust Game Engine Core
-
seawater
A high performance entity component system useful as a backend for developing GUI applications and video games
-
bevy-shaders
A collection of shaders for Bevy 💠
-
bevy_touch_camera
Touch camera for Bevy that supports drag and pinch to zoom
-
limnus-gamepad
Platform independent gamepad management
-
Rustic_Hangman
popular game Hangman
-
bevy_stat_bars
plugin for drawing floating stat bars
-
ryot_pathfinder
specialized pathfinding functionalities for Bevy 2D, essential for dynamic navigation and movement within games
-
devotee-backend
Backend library specification for the devotee project
-
island_map_generator_algo
Generation crate for an island map editor using procedural generation, Rust and Bevy engine
-
imperator-save
Ergonomically work with Imperator Rome saves (debug and ironman)
-
bevy_renet2
Bevy plugin for the renet2 crate
-
baba
Extremely simple library for games, inspired by love2d and raylib
-
yagl
Game Library
-
gl-capture
Capture screenshot in OpenGL
-
gb-sym-file
A parser for Game Boy sym files, fully conformant to the spec
-
forsyth
A pure Rust implementation of Tom Forsyth's 'Linear-Speed Vertex Cache Optimisation'
-
action_maps
A dynamic action mapping system for Bevy
-
miru-gl
OpenGL bindings for my personal game engine
-
gameboard
creating game board for text UI games
-
async_shared
signal implementation
-
godot-rust-cli-upgrader
A CLI tool to help you upgrade your Godot Rust CLI project between versions that introduce breaking changes
-
bevy_mod_simplest_healthbar
Not really healthbars, but at least it can be used to get some kind of healt indication
-
bevy_api_gen
Code generator tool for bevy
-
bevy_diagnostics_explorer
Bevy plugin that provides provides diagnostics into VSCode extension
-
bevy_single
Package allows more convinient access to single entity from bevy query
-
rift_insight
A third party API library for League of Legends
-
aeronet_webtransport
WebTransport IO layer implementation for
aeronet -
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
-
bevy_vach_assets
Bevy Vach Assets is a plugin for Bevy Engine that allows you to load assets from Vach archives
-
mini_asset_loader
A composable game asset-loading system
-
evenio
An event-driven entity component system
-
bevy_http
Bevy HTTP asset loader plugin
-
cyclone2d
A small 2D physics engine from 'Game Physics Engine Development'
-
gdnative_tweener
A port of DoTween(3rd party package for Unity) to Godot 3.5, using GdNative
-
pecs_http
Asynchronous operations for Bevy Engine
-
sheep
Modular and lightweight spritesheet packing library
-
rabex
wip UnityRustExtractor and patcher
-
rhythm-core
Core library for the rhythm games
-
VigilantLamp
Multi-target game engine / graphics library
-
moongraph-macros-syntax
creating moongraph-macros
-
morkovmap_rc
A data-driven, Markov Chain-based tilemap generator library and app. Single-thread-flavored.
-
beet_examples
Tools for building reactive structures
-
graphite_minecraft
crafting high-performance Minecraft servers
-
jabuwu/petty-party
Bevy Jam #1 Entry - Play against the worst board game opponent in the world
-
degen_toon_water
A toon water shader for bevy
-
bevy-fps-ui
Fancy FPS counter for Bevy Game Engine
-
renet2_steam
steam transport for the renet2 crate
-
anput-jobs
Jobs plugin for Anput ECS
-
bevy-tnua-rapier3d
Rapier 3D integration for bevy-tnua
-
aws-gamelift-server-sdk-rs
AWS GameLift Server SDK for Rust
-
freestuffapi
Freestuffbot API
-
playdate-rs
Safe Rust bindings for the Playdate SDK C-CPI
-
diceroll
dice rolling lib for RPG purposes
-
bevy_schedule_dispatch
Use equivalent functions to dispatch bevy ecs schedules
-
ecs-rs
A super-simple entity-component system in Rust
-
replace_ident
Replaces target ident with given ident in a token stream
-
starry-ecs
A crude ECS system
-
bevy_stardust_extras
Miscellaneous utilities for bevy_stardust
-
wasm4fun-graphics
Graphics primitives and subsystems for WASM-4 fantasy console
-
cc6502
making C compilers for the 6502 8-bits processor
-
reverie-engine-opengl
A toy game engine backed by OpenGL
-
bevylder
Voxels brought to bevy
-
smve
A voxel engine written in Rust
-
bevy-inspector-egui-rapier
bevy-inspector-egui integration for rapier
-
bevy-compose
Reactive UI framework for Bevy
-
repak
asset library format support
-
goblocks
Lua game engine based on Raylib
-
bevy_mod_chroma_api
Chroma API lib for bevy_mod_chroma
-
juke
🤖 A small engine for prototyping projects
-
penguin-application
Appbuilder and abstraction layer for building applications using legion ECS
-
procedural-generation
Procedurally generate maps elegantly
-
bevy_interact_2d
A Bevy plugin for 2d mouse interactions
-
bevy-tnua-avian2d
Avian 2D integration for bevy-tnua
-
quadify
Bevy plugin that integrates macroquad's windowing/rendering/sound API
-
petnat
A Petri net plugin for Bevy Engine
-
audir
Low-level audio library
-
rust_flightweather
Decodes METAR and TAF
-
bevy_tiled_blueprints
Allows reading tiled maps with properties
-
xanadu
A toy ECS library
-
gba_test
Testing framework for the Game Boy Advance
-
dotrix
3D Game Engine
-
space_undo
Subcrate for the space_editor crate. Contains undo functionality.
-
ayaka-plugin
Plugin runtime interface for Ayaka
-
bevygap_server_plugin
Plugin for bevy gameservers for use with lightyear on edgegap
-
alkyd
bevy crate for handling procedural textures and shaders
-
bitshifter/mathbench
Comparing performance of Rust math libraries for common 3D game and graphics tasks
-
zero_ecs_build
Build scripts for: ZeroECS: an Entity Component System (ECS), using only zero-cost abstractions
-
texture
Micro-engine for creating text-based adventures
-
wuestite_ecs
2D game engine written in rust
-
nova-r8
comprises Rust bindings for the Nova r8 game engine
-
salva3d
3-dimensional particle-based fluid dynamics in Rust
-
disqualified
type names more user-readable
-
bevy_button_transitions
Easy button transition styles
-
bevy_jakput_manager
input manager for bevy
-
rsaarelm/magog
Roguelike game
-
oasis-game-core
The core Oasis Game SDK engine
-
hextile
Handles coordinate math and other logic for hexagonal game maps
-
bevy_simple_camera_controller
Minimalistic camera controller
-
mycraft
A custom Minecraft server framework
-
game_board
A rectangular game board of squares, for use in games like chess or checkers
-
ascending_input
just a basic Library to help with winit input
-
advancedresearch-nano_ecs
A bare-bones macro-based Entity-Component-System
-
soku
Easy sudoku generation and solving
-
riichi-decomp
Japanese Riichi Mahjong Waiting Hand Decomposition
-
bevy_time
time functionality for Bevy Engine
-
bevy_ui_mod_alerts
Easy-spawn UIs that look like little popups
-
gigs
on-demand graphics jobs for the Bevy Game Engine
-
amethyst-editor-sync
Allows an Amethyst game to connect to an editor
-
bevy_lookup_curve
Editable lookup curve for Bevy
-
bevy_tilemap
Tilemaps with chunks for the Bevy game engine, a simple-driven game engine and app framework
-
bevy_dice
Physics-based dice rolls for bevy
-
ladfile
Language Agnostic Declaration (LAD) file format for the bevy_mod_scripting crate
-
index_camera_passthrough
Camera passthrough for Valve Index on Linux
-
critfail
parsing and rolling D&D 5e roll expressions
-
nzsc_core
The Official (Experimental) NZSC Core Library
-
wrym
Cross-platform, lightweight networking
-
ramirezmike/quien_es_el_mechaburro
A game made in one week for the Bevy engine's first game jam
-
pmd_message
that can read message*.bin files, used in 3ds pokemon mystery dungeon games
-
piston-dyon_interactive
interactive coding with the Piston game engine
-
cheats
A game shell backend
-
director
versatile, ergonomic state machine in Rust-lang
-
bevy_bones3
A voxel world storage and mesh generation plugin for Bevy
-
lichessbot
Lichess bot. Under construction.
-
bevy_ios_safearea
Bevy plugin to query device safe area insets
-
bevy_mod_fbx
Autodesk Filmbox (*.fbx) loader for Bevy Engine
-
y-craft
Craft your dream 2D gaming experiences with the X-Craft engine
-
bevy_regions
A region painting system using a u16 texture
-
rg3d-resource
Asset management crate for the rg3d engine
-
rymder
Unofficial agones client SDK
-
ellipsoid
2d cross-platform game engine
-
bevy_procedural_grass
A plugin for bevy to generate grass
-
simple_event_bus
A basic, simple event bus in Rust
-
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
-
theneikos/bevy_spicy_gamebase
-
vleue_kinetoscope
Animated GIF player for Bevy
-
logtra
A minimal logging library
-
playdate-display
High-level Display API built on-top of Playdate API
-
krust_core
krust core
-
cob_sickle_ui_scaffold
Scaffolding framework for sickle_ui
-
bevy_image
image types for Bevy Engine
-
bevy_device_lang
Crossplatform way to query device language setting
-
piston-ai_behavior
AI behavior tree
-
storylets
Embeddable storylet-based narrative engine for games
-
bevy_meshem
that offers a flexible and efficient way to generate meshes from a grid of Voxels
-
bangle
Strongly-typed angles, specified in radians, degrees, rotations, or percentages
-
bevy_smooth_pixel_camera
Smooth pixel-perfect camera for Bevy
-
axle_ecs
Axle's entity component system
-
lex-map_editor_std
standard types and parser for lex-map_editor
-
rliron
a roguelike algorithm library
-
bevy_registry_export
Allows you to create a Json export of all your components/ registered types of your Bevy app/game
-
notation_audio
Fun notation - audio features
-
lemon_engine
A game engine based off of Glium
-
romy
A runtime for portable, archivable and deterministic video games
-
bevy_tileset_map
An extension to bevy_ecs_tilemap, allowing for configurable tilesets, auto tiling, and more using the bevy_tileset crate
-
bevy_tiled_camera
A camera for rendering low resolution pixel art in bevy
-
fgruc
Fast graphics rendering utility collection // A collection of utils for graphics rendering and game making made with performance in mind
-
ivy-random
random utility functions to the ivy framework
-
bevy_python_ffi
run and interact with bevy apps from python
-
entity_store_helper
simplify using code generated by entity_store_code_gen
-
dumbledore
A ECS with async calls in mind
-
bevy_bad_sdr_bloom
Bevy plugin for a bloom-like glow effect that works with WebGL2
-
bevy_debug_texture
Replacement default/debug texture for Bevy games
-
glsp
The GameLisp scripting language
-
playdate-menu
High-level system menu API built on-top of Playdate API
-
bevy_fix_gltf_coordinate_system
A tiny plugin to fix the fact that Bevy does not respect the GLTF coordinate system
-
bevy_lunex_utility
Supporting crate for bevy_lunex
-
bevy_state_stack
An improved state stack for bevy
-
bevy_voronoi
A low-level Bevy library to generate Voronoi diagrams from 2d meshes
-
bgel
apply Khronos glTF extensions to Bevy models
-
focus
The Focused Entropy game engine for 2D game development
-
three
Three.js inspired 3D engine in Rust
-
oxygengine-animation
Animation module for Oxygengine
-
steel-server
The game server for the steel game engine
-
image-gameboy
Convert images to Game Boy-compatible 2bpp format
-
bevy-firebase-auth
firebase auth for the bevy game engine
-
bevy_glfw
GLFW window backend for Bevy
-
bevy-rrise
A Wwise Bevy integration
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
bevy_rl_shooter
👾Multi-Agent 🎮 FPS Gym Environment with 🏋️ bevy_rl
-
swamp-app
Application management for 2D pixel perfect sprite rendering
-
gilrs-core
Minimal event-based abstraction for working with gamepads
-
oxygengine-backend-web
Web backend module for Oxygengine
-
ninres
Read commonly used Nintendo file formats
-
forky_play
Rust Utilities
-
bevy_ecss
Allows using a subset of CSS to interact with Bevy ECS
-
keeshond_editor
Editor for the Keeshond Game Engine
-
limnus-window
Easily create and manage windows across multiple platforms for game applications, leveraging the power of the
winitlibrary -
ivy-presets
Contains common presets for quickly setting up an application
-
bevy_mod_scripting_rhai
Necessary functionality for Rhai support with bevy_mod_scripting
-
bevy_serde_project
Stateful, structural and human-readable serialization crate for the bevy engine
-
rs-tiled_json
A helper library to load JSON-formatted Tiled maps
-
ada
2D Primitive Shapes Rendering Library
-
nimble-participant
Nimble Participant
-
tm-rs
FFI bindings for the machinery api
-
om-fork-distance-field
Temporary fork! Generate distance fields from images for pseudo-vector rendering
-
sustenet-shared
Sustenet shared library that contains the common code used by all modules
-
curseofrust-net-foundation
Bare networking layer on the top of unisock - for curseofrust
-
bevy_mod_ui_texture_atlas_image
Draw images from texture atlases with the Bevy UI
-
godot-ffi
Internal crate used by godot-rust
-
bevy_ecs_markers
🏷️ Markers for Bevy ECS Entities
-
bevy_koto
Koto support for Bevy
-
bevy_bundletree
Spawn trees of bundles in the Bevy game engine
-
dedenne
Cute little generators using async/await in stable rust
-
fishsticks
gamepad input library
-
mc-repack-core
repacking Minecraft mods and resource packs to optimize size and loading speed
-
const-tweaker
Tweak constant variables live from a web GUI
-
timberwolf
a high-performance 3D-focused game engine
-
thomas
An ECS game engine
-
chess-turn-engine
Chess turn engine library with all chess rules implemented. Can be used to implement a chess game.
-
shine-stdext
SHINE. General utilities for the general purpose multi-threaded rendering engine.
-
yarnspinner_runtime
Runtime / VM for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
micro_quest
Structures and systems for managing game dialog & quests
-
fyrox-animation
Flexible Animation System
-
apecs-derive-canfetch
helper for writing apecs procedural macros
-
chess_js
chess.rs
-
steam-vent-proto
Protobuf structs used by the Steam client protocol
-
shuftlib
A generic library for card games and related topics
-
bracket-algorithm-traits
Traits required for the bracket-* crates. Adapt your maps to the traits with Algorithm2D, Algorithm3D and BaseMap.
-
corange-rs
interface to the Corange game engine, written in Pure C, SDL and OpenGL by Daniel Holden. Features include: deferred rendering, UI rendering, text rendering, multiple lights, post-processing effects…
-
space_shared
Subcrate for the space_editor crate. Contains the common types used in the space_editor
-
grid_plane
Grid plane for the bevy game engine
-
bones_render
Core rendering types for bones_lib
-
moonshine-check
Validation and recovery solution for Bevy
-
inexor-rgf-model-random
Inexor - Reactive Graph Flow - Model - Random
-
bevy_quill_obsidian
An opinionated set of editor-focused widgets built on Bevy and Quill
-
chess_perft
package runs a 'perft' test on a particular chess position. This makes every move out to a certain depth, and counts the number of leaf-nodes. This is used to verify that move generation is correct and fast…
-
delos
An opinionated engine for building games in Rust
-
playdate-color
Color extension for Playdate API
-
inexor-rgf-model-string
Inexor - Reactive Graph Flow - Model - String
-
basis-universal-sys
Bindings for the basis-universal Supercompressed GPU Texture Codec by Binomial
-
bevy_xpbd_3d_interp
interpolation of bevy_xpbd rigidbodies
-
stick
Platform-agnostic asynchronous gamepad, joystick and flighstick library
-
game_tookit
Experimenting with CG and physics
-
piston3d-cam
3D camera and navigation
-
rg-chess
Chess Game with graphical interface
-
bevy_mod_scripting_lua
Necessary functionality for Lua support with bevy_mod_scripting
-
resources_package
Macro that allows you to package files inside your libraries or executables
-
bevy_blacklight_material
A blacklight material plugin for the Bevy engine
-
bevy_dogoap
-
dip_task
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
easytext
A dead simple, easy-to-use and basic text rendering library for wgpu
-
sunshine
A raycasting game engine built on miniquad
-
game_engine_core
The main loop of a game engine
-
bevy_replicon_example_backend
transport intended only for examples
-
cvars-console
In-game console using the cvars crate for configuration - internal crate, use cvars-console-fyrox or cvars-console-macroquad in your game
-
limnus-asset-id
ownership asset ids
-
silver_animation
A basic animation system for quicksilver
-
coup
game implemented in the CLI
-
fyrox-scripts
Standard scripts for the Fyrox engine
-
bevy_clap
A bevy plugin to parse CLI arguments with clap
-
mun_compiler
Binary compilation functionality for Mun
-
halite3bdk
Bot Development Kit for Halite III
-
robloxapi
Async Rust API Wrapper for Roblox
-
dotrix_overlay
Overlay for Dotrix 3D Game Engine
-
rg3d-sound-sdl
Use rg3d-sound with SDL's audio subsystem
-
bevy-trait-query-0-14-0
trait queries for the bevy game engine
-
bevy_procedural_audio
A Bevy plugin that integrates FunDSP into Bevy
-
dodgy
ORCA, a local collision avoidance algorithm
-
terminity
Enviroment for the best terminal UI quality for games
-
shura
A fast cross-plattform 2D component-based game framework
-
zero_sum
An analysis engine for zero-sum games with game implementations
-
otter-support
Otter game system; support code Rust crate
-
witer
An iterator-based Win32 windowing library
-
bevy_component_extras
containing QOL bevy components for common features that other crates might want to interface with
-
polako
Define the Bevy tree with
eml!, style it using a very-css-likeesssyntax and relate data data withbind!andconnect! -
epicinium_server
An asynchronous multiplayer server for the strategy game Epicinium
-
franim
A frame animation library for
no_stdgame-development -
maikklein/unreal-api
Rust integration for Unreal Engine 5
-
unity-native-plugin-vulkan
Unity Native Plugin API (Vulkan) for Rust
-
catgirl-engine-common
Common crate for the catgirl-engine crate
-
lib_sens
that converts sensitivities between video games and synchronizes them to configuration files
-
bevy_streamdeck
Elgato Stream Deck plugin for Bevy
-
renet2_setup
Setup utilities for renet2
-
bevy_toon_shader
Toon shader for the Bevy game engine
-
rafx-renderer
Rendering framework built on an extensible asset pipeline
-
ivy-templates
Provides
-
bevy_mod_actuate
A reactive user-interface framework
-
bevy_tiled_loader
Asset loader for the Tiled data parsed
-
minigene
A minimalist terminal game engine
-
bracket-random
Random number generator (xorshift based), focused on dice rolling. Optionally includes parsing of RPG-style dice strings (e.g. "3d6+12"). Part of the bracket-lib family.
-
bevy_2d_collisions
Bevy plugin to easily detect aabb collisions
-
bevy_oneshot
ohe-shot systems for Bevy
-
obel_editor
core App functionality
-
pulz-schedule
For scheduling systems and managing their resources
-
wolf_engine_events
An event modules for Wolf Engine
-
fyrox-build-tools
Build tools for Fyrox Engine
-
rattle_items_match
Matching is not limited to character strings. I'm trying to make a game AI.
-
schminput_rebinding
Input Rebinding for Schminput
-
beetmash_template
An example workflow for publishing Bevy apps and scenes to Beetmash
-
mangrove-engine
2D game engine powered by swamp-script
-
limnus-audio-sample
Load .wave files into asset
-
nimble-seer
Nimble Prediction
-
bevy_liquidfun
A Bevy friendly wrapper of Box2D and LiquidFun
-
byml
Nintendo BYML (binary YAML) library in Rust
-
orthrus-panda3d
Orthrus module supporting the Panda3D engine
-
extol_image_font
Render pixel fonts from PNGs in Bevy
-
hw-skymodel
A pure Rust implementation of Hosek-Wilkie Skylight Model
-
bevy_vr_controller
VR character controller for Bevy
-
inochi2d
Pure Rust implementation of Inochi2D, the realtime 2D puppet animation framework
-
freecell
Game objects and rules for the solitaire card game FreeCell
-
nestools
A set of Rust tools used to help make NES games, mostly used for tile compiling
-
z-buffer-game
Survival/strategy game with ascii-art graphics
-
gamesync_server
Server-side multiplayer game networking library
-
bevy_tileset_tiles
Tile definitions used by bevy_tileset
-
shogi_usi_parser
Conversion from strings in USI format
-
shipyard_rapier2d
An integration with the physics engine rapier, for the shipard ECS
-
gravitron_renderer
Gravitron Renderer
-
screen-selector
A reimplementation of Unity’s ScreenSelector.so plugin, using GTK 4
-
tarator
game engine wie an ECS and a UI
-
ugli
Game ENGine
-
rusty_gfx
Create windows, display graphics, handle input events (keyboard, mouse, etc.). Part of the rusty_engine game engine.
-
two-player
Deterministic two-player games
-
apparatus
A 2D game engine
-
gurgle
dice rolling crate
-
bevy_kill_my_cache
A plugin that kills your cache, but makes the Bevy scheduler go brrr
-
quarks
A general purpose engine. Not ready WIP
-
reactor_spatial
A set of 2D spatial utilities for Bevy, including handling transform propagation
-
snake-rs
handle the logic for the classic game snake
-
noise-functions-config
Configurable noise generator for
noise-functions -
rbx_types
Types used to represent Roblox values
-
wrym_tcp
TCP transport for wrym
-
bevy_ecs_ldtk_macros
Derive macros for bevy_ecs_ldtk
-
fyroxed_base
A scene editor for Fyrox game engine
-
aeronet_websocket
WebSocket IO layer implementation for
aeronet -
wolf_engine_framework
A complete, "batteries-included" framework for Wolf Engine
-
bevy_pixel_perfect
Pixel perfect post processing effect for Bevy similar to that in Astortion
-
overworld_resource
Overworld Resource Library - Resource management
-
steel-engine
The steel game engine core library
-
bevy_fpc_core
Core features for
bevy_fpc -
bevy_global_input
Global mouse + keyboard input for bevy - doesn't require a focused window
-
bevy_kira_audio
Bevy plugin for dynamic audio
-
bevy_prototype_schedule_states
Bevy plugin for states as schedules
-
openlegends-server
OpenLegends Game Server
-
evnet
An event driven peer to peer networking plugin for bevy built ontop of bevy_matchbox and webrtc
-
valve-sdk13-rng
A port of Valve's SDK13 Uniform random number generator in Rust
-
bevy_state
Finite state machines for Bevy
-
zengine
2D ECS game engine
-
bevy_points
Points mesh plugin for Bevy
-
amethyst-console
imgui frontent to cvar
-
pyrrhic-rs
A pure-Rust library to probe Syzygy Tablebases within a chess engine
-
anput-spatial
Spatial queries plugin for Anput ECS
-
bevy_async_system
ability to wait for game status asynchronously
-
unity-unpacker
A CLI utility for unpacking the assets from Unity's .unitypackage file
-
elikar
asynchronous ECS game engine
-
vach
archiving format, designed for storing assets in compact secure containers
-
oxygengine-visual-novel
Visual Novel module for Oxygengine
-
hivetuilib-ai
Generic minimax AI algorithm for hivetuilib
-
obel_reflect_utils
Provide the token utils fro obel_reflect
-
blunders
UCI chess engine application
-
keeshond_datapack
framework for loading and caching game assets
-
carrier-pigeon
networking library for games
-
linearify
Fast region file format manipulation
-
rayngin
3D 6DF framework/engine for approach&click quests in rectangular chambers with objects consisting of balls
-
hill_vacuum_lib
Main HillVacuum library
-
mental-poker
writing trustless card games
-
main_game_loop
collection for building a winit game loop
-
gl-headless
Easiest way to create a headless OpenGL context
-
agb_image_converter
converting graphics for use on the Game Boy Advance
-
gloss-hecs
A wrapper over hecs for easy use with gloss
-
bevy_flurx_wry
mechanism to create a webview based on wry
-
starry-night
A toy game engine
-
piston-texture
A generic library for textures
-
bevy_2delight
A collection of tools to make building 2d games in Bevy _delightful_
-
limnus-default-keys
Default keys implementation for limnus
-
chunked
An Entity Component System that works by organising like entities into chunks
-
limnus-assets
store assets in a slot map
-
ryot
MMORPG library based on the concepts of open tibia written in rust and bevy
-
poirebot
A chess bot engine written in Rust
-
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_poly_level
A 2d polygon-based level editor for bevy game engine
-
maikor-vm-interface
Interface for VM (simulates hardware)
-
bevy_blender_utils
Bevy companion plugin for bevy_blender_utils Blender addon
-
sarc-rs
parsing and creating Nintendo SARC files in Rust
-
chargrid_graphical
Graphical chargrid context
-
bevy_prank
Opinionated Unreal Engine inspired spectator camera for the Bevy game engine
-
bevy_center
A Bevy debug plugin that draws a colored marker to the center of the screen on startup
-
resphys
2D AABB only game collision detection/resolution engine
-
flappy
version of a game that is definetly not flappy bird using the piston engine
-
thebracket/rltk
A CP437/ASCII terminal library and helpers to make creating roguelike games in Rust easy. Similar to libtcod, but aiming to be Rust-native.
-
bevy_debug_overlay
Bevy plugin to show debug information like fps, frametimes window configuration and more
-
renderling_ui
User-friendly real-time 2d rendering. 🍖
-
bevy-overlay-wrapper
CEF bindings for the Bevy Overlay plugin
-
wasm4fun-logo
Logo animation for WASM-4 fantasy console
-
render-to-texture
Render to a texture using Bevy and optionally retrieve the contents in the Main World
-
ayaka-model
Ayaka high-level runtime
-
poirebot-lichess
A chess bot for Lichess written in Rust
-
bevy_diagnostic_visualizer
Visualizations for Bevy game engine diagnostics
-
ecs
An Entity Component System (ECS) Framework
-
bevy_ios_app_delegate
Bevy Plugin to receive iOS AppDelegate callbacks
-
obel_diagnostic
diagnostic functionality
-
wecs-core
core of the wecs package
-
pocket-relay-core
Core module for Pocket Relay which contains shared state as well as game logic
-
gvfs
providing a configurable virtual file system for game assets, a la PhysFS
-
qilin
Lightweight Game Engine for making fun 2d Games in Rust
-
wolf_engine_window
high-level window API for video games
-
open-oak
2D game engine and rendering library
-
magma_api
API of the Magma3D game engine
-
rafx-assets
Rendering framework built on an extensible asset pipeline
-
namigator-sys
Direct bindings for the namigator pathfinding library for World of Warcraft
-
limnus-app
Application management
-
sustenet-cluster
Sustenet's cluster module that connects to the master server and accepts client connections after being registered
-
gsfw
tiny game server lib
-
recast-rs
Bindings for Recast from recastnavigation
-
vulk-test
Vulkan bindings for Rust, except only the bleeding edge features
-
openlegends-api
Shared Client/Server API
-
bevy_rng
A Bevy game engine random number generator plugin
-
pecs
Asynchronous operations for Bevy Engine
-
oxygengine-input-device-web
Web input devices module for Oxygengine
-
bevy_retro_ui
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
astral-string
String library for the Astral Engine (WIP)
-
oasis-game-contract
The generic contract for the Oasis Gaming SDK
-
oxygen_orbit
Oxygen Orbit is an API library (for Perlin Noise and more) mainly developed for the Oxygen Game Engine
-
dexterous_developer_dynamic
A modular hot reload system for rust
-
russimp-sys
Raw Assimp bindings for Rust
-
wasm4fun-input
Input primitives and subsystems for WASM-4 fantasy console
-
coin_toss
minimalist library for coin tossing
-
bevy_kot
Koe's Bevy toolkit
-
bevy_blob_loader
Bevy plugin for loading assets from JavaScript blob URLs
-
kayak_font
An SDF font renderer for Kayak UI and the Bevy game engine
-
bevy_plane_cut
A plane cut material for bevy
-
yuxii
ECS-based 3D game engine
-
bevy-postgrest
postgrest bindings for bevy apps
-
dwat20
emulating dice rolls
-
word_search
generate and display a configurable word search grid
-
wutengine_core
Core datatypes and traits for WutEngine
-
steamid-ng
SteamID type with functions to parse and render steam2 and steam3 IDs
-
gravitron_window
Gravitron Window
-
generic_asset
A upgraded version of Tantans asset loading macro for bevy 0.12
-
spades
A popular four person card game implemented in Rust
-
tic80-sys
An opinionated interface into the tic80 system
-
console_renderer
A console renderer for the ABC Game Engine
-
web-sys-stream-utils
Stream-related utilities for web-sys
-
bevy_crt
A package for the bevy engine which enables the use of a CRT effect
-
behavior-tree
behavior tree library for rust!
-
bevy_hanabi_loader
A wrapper around bevy_hanabi that lets you define your vfx files in RON format and load them into bevy
-
ryot_tibia
Specializes in managing and integrating Tibia-specific legacy assets, tailored for games inspired by the classic Tibia
-
maikklein/unreal-movement
Rust integration for Unreal Engine 5
-
bevy_event_priority
Bevy plugin providing priority based event handling
-
chessbored
a chess board with movable pieces that behaves like a chessboard on the table
-
bones_asset
Asset interface for bones_lib
-
pg_sdl
A SDL2-superset library for easy game or application development
-
bevy_tmx
Scene loader for .tmx files created by the Tiled map editor
-
degen_toon_clouds
A toon cloud shader for bevy
-
bevy_fabrik
IK solver for Bevy using FABRIK algorithm
-
mextk-sys
Bindings to the MexTK library for writing mods for Super Smash Brothers Melee
-
bevy_ios_review
Bevy plugin for to request ios native review API from within the App
-
recast_navigation
Rust wrappers for recast navigation
-
parabox-parser
The parser and the executor for the Parabox language
-
sprocket_engine
A vulkan game engine
-
island_map_generator_bevy
Island map editor using procedural generation, Rust and Bevy engine
-
atlas
Texture atlas generation (guillotine with dynamic resizing.)
-
bevy_input_mapper
Input binding has never been easier: a Bevy game engine plugin designed with stunning simplicity in mind
-
z4-engine
a multiplayer real-time decentralized game framework
-
bevy_activation
Entity activation manager for Bevy
-
headless_webview_engine
Headless Webview implementation for Linux - WIP
-
bloke
A video game avatar system, similar to Nintendo's Mii - but open source and for PC / phone games
-
stockton-bsp
parsing Q3 .bsp files
-
ambient_project_rt
Runtime support for code generated by the Ambient project macro
-
bevy-orbit-controls
An orbit controls plugin for bevy
-
immediate_stats_macros
Game stats that reset every frame, inspired by immediate mode rendering
-
bevy_utilitarian
A collection of mostly maths, interpolation and geometric utilities that aim to make Bevy programmers happier
-
expedition
Rich text styling and formatting library
-
spew
helper for spawning objects in Bevy
-
bevy_stokes
A bevy plugin providing a thin and ergonomic wrapper around laminar
-
bevy_shader_mtoon
Bevy MToon shader
-
darkforge_rng
Dark Forge is a library and extension for Godot engine that implements the Blades in the Dark SRD by One Seven Design
-
graphite_server
Minecraft server implementation for the graphite_minecraft project
-
bevy_retrograde_ui
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
pi_ecs
An excellent ECS framework
-
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
-
jam_theme_picker
A Bevy + mdbook enabled template repo to build on
-
bevy_aoui
A light-weight anchor-offset based 2D sprite layout system for the bevy engine
-
zengine_ecs
ZENgine's entity component system
-
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.
-
rantz_cereal
A plugin for Bevy for handling saving and loading
-
crankit-game-loop
A safe and ergonomic entry-point for playdate games using
playdate-sys -
bevy_dexterous_developer_dynamic
A modular hot reload system for rust
-
swamp-script-compile
Compile utility functions
-
bevy_dyn_component
Safe dynamic components API for Bevy
-
rhusics-transform
Physics library for use with
specs -
easel-rs
A shader playground for creating high resolution digital paintings
-
astral-util
Astral Engine (WIP)
-
ayaka-script
First-class script language in Ayaka
-
astrelis
A 2D game engine
-
nate-engine-core
Core Code for a game engine I created just for fun
-
bevy_generative_grammars
A plugin for handling generative grammars in bevy
-
ambient_ecs_editor
Ambient ECS editor. Host-only.
-
mun_syntax
Parsing functionality for the Mun programming language
-
bevy_assets_tar_zstd_bundler
Asset loader using .tar.zstd
-
myopic-core
Core chess utilities
-
softbuffer
Cross-platform software buffer
-
inexor-rgf-model-result
Inexor - Reactive Graph Flow - Model - Result
-
maikklein/unreal-reflect
Rust integration for Unreal Engine 5
-
luminol-graphics
Luminol's graphics backend, used for rendering sprites and tilemaps
-
hydrate
Game asset pipeline and authoring framework
-
devcaders
Devcade input support library for Bevy+Rust!
-
space_prefab
Subcrate for the space_editor crate. Contains the prefab systems and components.
-
bevy_window
windowing functionality for Bevy Engine
-
blokus
game engine
-
bevy_easy_stats
easy tool to manage stats in Bevy
-
hanjie
A nonogram game engine using Bevy
-
bevy-pigeon
The bevy plugin for carrier-pigeon
-
butsuri
Currently only an asset that provides 2d collision detertor and kinematics, build from scratch in bevy
-
bevy-pixel-map
A pixel based tilemap for bevy!
-
bevy_picking_core
A modular picking plugin for Bevy
-
niko
wasm game engine
-
bevy_ui_material
Plugin to use materials for UI
-
bevy_gltf
Bevy Engine GLTF loading
-
storm
A personal 2D game engine designed for performance
-
piston-viewport
storing viewport information
-
ayaka-runtime
Ayaka low-level runtime
-
rscenes-raylib-connector
Raylib connector for Rscenes 2
-
bevy_2delight_physics
2d physics system that's _delight_ful to use
-
crankit-input
An ergonomic input API for the playdate
-
godot-bindings
Internal crate used by godot-rust
-
bevy_mod_gltf_patched
Bevy Engine GLTF loading (patched)
-
steel-dynlib
The dynamic library for the steel game engine to reload at runtime
-
kit
An small game engine for 3D games
-
bevy_ui_animation
A GSAP-like animation plugin for Bevy UI
-
bevy_transform
transform functionality for Bevy Engine
-
bevy-trait-resource
Get resources by trait
-
notation_bevy
Fun notation - bevy features
-
oni
Later on, there will be a framework for mmo games
-
minecrevy
A toolkit for building Minecraft servers in Rust with Bevy
-
newport_engine
Core runnable library for the Newport engine
-
bevy_diagnostics_inspector
Inspector plugin for the bevy game engine
-
spring_motion
Small&simple spring spring motion library
-
grr-imgui
grr backend for imgui
-
emerald
A lite, fully featured 2D game engine
-
geng-net
Game ENGine
-
tmx-rs
Loader for Tiled map editor xml files (.tmx)
-
bevy_diagnostic_vertex_count
Bevy diagnostics plugin for counting vertices of all present meshes in a world
-
vujio_client
vuj.io client utilities
-
recastnavigation-rs
binding for recastnavigation path finding library adds cross-platform deterministic
-
aether_spyglass
A general-purpose extensible inspector for bevy engine
-
bevy_kot_ui
UI utilities for bevy_kot
-
bevy_aseprite
Bevy aseprite loader
-
godot-cell
Internal crate used by godot-rust
-
ggsdk_internal
that exports several types related to game development
-
sotora-game/sotora
[WIP] showcase game made in the Bevy game engine
-
crankit-time
An ergonomic time API for the playdate
-
mineswipe
playing Minesweeper!💣
-
space_bevy_xpbd_plugin
Space XPBD plugin for space_editor crate
-
skillratings
Calculate a player's skill rating using algorithms like Elo, Glicko, Glicko-2, TrueSkill and many more
-
overworld_progression
Overworld Progression Library - Experience, Milestone and Level progression
-
rain2d
2D game engine
-
bevy_fly_cam
Flycam plugin for Bevy 0.14
-
moongraph
Schedules and runs DAGs accessing shared resources. 🌙
-
bevy_mod_2d_hierarchy
Bevy plugin for more ergonomic 2d
-
gpm
A package manager for godot
-
bevy-simple-state-machine
A rudimentary animation state machine system for Bevy
-
wow-wmo
Parser for World of Warcraft WMO (World Model Object) files (1.12-11.0)
-
ryot_utils
General utilities and helpers for the Ryot framework, supporting a wide range of common game development tasks
-
treasury-id
ID generator for treasury
-
anne_terminal_input
A terminal input handling library using crossterm for Rust
-
sprite-gen
Procedurally generate pixel sprites library
-
bevy_proto_typetag
bevy_proto with typetag support
-
dashing
ASCII-style roguelike engine
-
openlegends-asset
Game asset for OpenLegends Card Game
-
limnus-system-state
Keeps the state that is provided to systems
-
pecs_core
Asynchronous operations for Bevy Engine
-
rialight
module
-
mrchantey_beetmash_sewb
Exploration of the Aboriginal SEWB framework with Beetmash
-
bevy_4x_camera
A 4X style camera for bevy
-
material_designer
Custom Material designer for Bevy
-
flatbox
Rust ECS game engine with editor written in C#
-
luminol-web
Web-specific code for running Luminol
-
bevy_mod_debug_console
Bevy plugin to use console to get information from ECS
-
shine-store
SHINE. Storage and container module for the shine engine.
-
vek2d
2D Vectors
-
physx
High-level Rust interface for Nvidia PhysX
-
romy-wasmer
A runtime for portable, archivable and deterministic video games
-
bevy_replicon_renet2
Integration with renet2 for bevy_replicon
-
bevy_sprite_instancing
A Bevy plugin to render lots of instanced sprites
-
shakmaty-uci
Universal Chess Interface (UCI) message parser
-
bevy_ui
A custom ECS-driven UI framework built specifically for Bevy Engine
-
ivy-image
stb image loading library for ivy
-
horizon_logger
Color-coded logging system for Horizon game server
-
minecrevy_text
handling Minecraft text components
-
tanton
A blazingly-fast chess library
-
nimble-sample-game
Nimble Sample Game Types
-
rps
Rust bindings for RPS API
-
srs2dge
2D Game Engine
-
wgpu_tokio
Async bindings using tokio for wgpu
-
godot_rust_helper
CLI tool to help you create and update Rust modules for your Godot projects
-
san-rs
parsing standard algebraic notation (SAN)
-
bevy_entity_system
Adds systems that only operate on single entity
-
fna3h
FNA3D types in a hierarchy
-
landmass_oxidized_navigation
An integration between bevy_landmass and oxidized_navigation for AI navigation
-
playdate-scoreboards
High-level Scoreboards API built on-top of Playdate API
-
godot-bevy-macros
Procedural macros for godot-bevy integration library
-
planck_ecs_bundle
Adds bundles to planck_ecs
-
check-buddy
The main system of check buddy
-
bevy_serialization_assemble
assembling assets from entities and components
-
wecs-events
events of the wecs package
-
curses-game-wrapper
wrapper for curses games to make game AI
-
bevy_pause
A very simple pause plugin for Bevy
-
bevy_tasks
A task executor for Bevy Engine
-
shipyard_rapier3d
An integration with the physics engine rapier, for the shipard ECS
-
parry3d-f64
3 dimensional collision detection library in Rust. 64-bits precision version.
-
licoricedev
Lichess API. Development version.
-
cargo-geng
Game ENGine
-
bevy_sprite_animation
A Node Based Sprite Animatio Plugin, Bassed on Aarthificial's Reanimator
-
async-uci
An async UCI Implementation over the tokio runtime
-
minimum
A collection of utilites for games
-
wutengine_ecs
The core implementation of the WutEngine ECS
-
bevy_retrograde_ldtk
A Bevy Retrograde plugin for reading the LDtk 2D tile map format
-
ladfile_builder
Language Agnostic Declaration (LAD) file format for the bevy_mod_scripting crate
-
bevy_cursor_hovering_sprite
a very lightweight plugin for bevy engine to check if a cursor is hovering on one 2d sprite
-
vampirc-io
asynchronous, non-blocking, UCI protocol–based communication between chess UIs and chess engines
-
bevy_editor_iris_plugin
Plugin logic for bevy_editor_iris
-
bevy_rollback
A rollback library for the Bevy game engine
-
swamp-vm-host
host interface for the swamp VM
-
pulz-ecs
An archetype based ECS
-
edger_bevy_util
edger.dev bevy utilities
-
despero-hecs
A fast, minimal, and ergonomic entity-component-system library
-
little-camera
little engine virtual camera abstraction
-
text_adventure
a program to allow for the creation of simple text adventure games using JSON files
-
beet_router_parser
Tools for building reactive structures
-
bevy_2dviewangle_macro
Bevy plugin for easier to switch texture base on view angles (derive macro)
-
glyph_packer
packing glyphs into a texture
-
lux-ik
Full Body Inverse Kinematics (FBIK) for games
-
merosity
(wip) competitive stacker game
-
nesbox_utils
Quickly develop NESBox games
-
specs_sprite
sprite component for specs
-
moonshine-util
Collection of utilities for Bevy
-
rafx-shader-processor
Rendering framework built on an extensible asset pipeline
-
wgpu-biolerless
Use WGPU for your graphical application but without the usual biolerplate
-
discord_game_sdk_sys
Low-level bindings for the Discord Game SDK
-
scone
game engine
-
regigigas
Registration system for game objects
-
art-stamps
Artwork stamps tool to quickly stamp out shaapes and make beautiful castles or houses as an SVG
-
conditional_commands
Bevy Commands extension
-
bevy_texture_atlas_tools
tools for working with Bevy Texture Atlases
-
nimble-sample-step
Nimble Sample Step Type
-
reactor_random
Mostly just a wrapper around fastrand for a bunch of types. Supports bevy and reactor_spatial2d.
-
bevy_proto_backend
Backend crate for bevy_proto
-
nimble-ordered-datagram
Nimble Ordered Datagram
-
ecs-tiny
A minimal ECS supporting entity and component insertion/removal, association, and single-type iteration
-
zengine_asset
asset functionality for ZENgine
-
piston_window
The official Piston window wrapper for the Piston game engine
-
bevy_config_cam
An easy plug-n-play multifunctional camera that allows for easy setup of a camera and player for a scene
-
spring-ai-sys
Bindgen bindings for SpringRTS games
-
kaige_ecs
Fork of the Legion ECS library, with some changes to make it more suitable for use in Kaige
-
limnus-system
Limnus systems
-
fly_bevy
Cool utilities for the Bevy game engine
-
uciengine
Use chess engine wrapper supporting uci command necessary for playing a game. Analysis is not supported.
-
ambient_cameras
Ambient cameras. Host-only.
-
limnus-screen
platform neutral screen and window types
-
bevy-better-events
better events and related objects for bevy
-
bevy_input
input functionality for Bevy Engine
-
fyrox-dylib
Dynamic library for Fyrox Game Engine
-
luminol-filesystem
Luminol's virtual filesystem
-
inexor-rgf-model-git
Inexor - Reactive Graph Flow - Model - GIT
-
bevy_color
Types for representing and manipulating color values
-
bevy_atomic_save
An atomic save/load system for Bevy Game Engine
-
nanos-sdk-rs
nanos-world module SDK bindings for Rust
-
bevy_decorum
A highly customizable window decoration plugin for the Bevy engine, inspired by tauri-plugin-decorum
-
edger_bevy_shape
edger.dev drawing 2D shapes easily
-
bevy_prototype_inline_assets
Bevy plugin for loading assets that are bundled into the binary
-
hom
3D modeling program/viewer
-
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
-
lnkit
Multiplayer game library
-
range2d
An iterator for traversing a 2D rectangular coordinate space
-
blizzard-engine
Blizzard Game Engine ❄️ is a modular ECS game engine
-
bevy_mod_scripting_common
Traits and syn structures for language implementors
-
overworld_dice
Overworld Dice Library - Dice components
-
google-games1
A complete library to interact with Games (protocol v1)
-
fmc_protocol
The fmc protocol
-
rg3d-physics
Physics library for rg3d-engine
-
limnus-resource
resource container
-
tictactoe_menace_c
Tic Tac Toe game with a Menace AI
-
bevy-tnua-xpbd2d
XPBD 2D integration for bevy-tnua
-
bevy-atlas-loader
Bevy plugin for defining and loading 2D TextureAtlas images
-
bevy_flurx_ipc_macro
provide ipc-command macro for bevy_flurx_ipc
-
omn-sprites
A small library for sprite sheet animation
-
treasury-store
Treasury storage
-
sustenet-client
Sustenet client used to connect to the master and cluster servers
-
bevy-topdown-camera
3d topdown camera for Bevy
-
swamp-script
script language for embedding
-
bevy_outline
Pixel-Perfect Outline Shader for Bevy
-
nanquim
3d game framework
-
wgsl-inline
A macro used to embed WGSL within Rust
-
oxygengine-ha-renderer-tools
Tools for Hardware Accelerated renderer module for Oxygengine
-
rekt-common
Common lib to use the rekt-protocol. See the crate homepage to check the protocol RFC.
-
bevy_mod_static_inventory
Static inventory for Bevy
-
limnus-audio-stream
Audio low level stream
-
z4-types
Z4 game framework types
-
edger_bevy_egui
edger.dev egui helpers
-
aeronet_steam
Steam networking IO layer implementation for
aeronet -
bevy-embasset
A Bevy plugin to embed assets in your game, or load assets from other sources!
-
nucleation
A high-performance Minecraft schematic parser and utility library
-
space_editor_ui
Subcrate for the space_editor crate. Contains the UI for the editor.
-
twors
2D game engine based on canvas and WASM
-
ryot_sprites
Focuses on sprite management, handling animations and graphical representations for dynamic visual content in games
-
wutengine_util_macro
Internal utility macros for WutEngine. Not meant for users
-
bones_bevy_renderer
Bevy rendering implementation for the bones_framework
-
steering
calculations for autonomous agents
-
pistoncore-glfw_window
A GLFW window back-end for the Piston game engine
-
srs2dge-presets
2D Game Engine
-
ryot_assets
Manages asset loading and processing, offering robust tools for efficient game resource management
-
bevy_ptr
working with untyped pointers in a more safe way
-
w-pgn
A pgn parser written in Rust
-
game_chess_cui
Command user interface ( CLI ) for chess game implemented for educational purpose
-
y-engine
A micro-engine that handles boilerplate (winit, wgpu, etc.) and adds quality-of-life features for easy application setup
-
astral-engine
Astral Engine (WIP)
-
rg3d
3D Game engine
-
fyrox-texture
Texture utilities for Fyrox Engine
-
bracket-embedding
resource embedding services for bracket-lib
-
geng-utils
A collection of utilities for Geng engine
-
heron
An ergonomic physics API for 2d and 3d bevy games. (powered by rapier)
-
newport_math
Math library that also works with spirv shaders for Newport engine
-
wgpu-tilemap
wgpu middleware for GPU-accelerated tilemap rendering, primarily targeted at 2d games
-
catgirl-engine-macros
Procedural macro crate for the catgirl-engine crate
-
bevy_retrograde_text
Bevy Retrograde's text rendering implementation
-
zengine_engine
engine functionality for ZENgine
-
tsukurou_engine
Reference Tsukurou! engine implementation
-
lottie-player
Bodymovin lottie file format player
-
spectra
Demoscene framework
-
mun_memory
Memory management functionality for Mun
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
dmsdk_ffi
Auto-generated bindings to Defold's dmSDK
-
bevy_term
Easy terminal event handling and rendering with Bevy!
-
bevy_quill_obsidian_inspect
A reflective property inspector widget built on Bevy, Quill and Quill/Obsidian
-
bevy-debug-camera
camera plugin perfect for debugging in 3D bevy games
-
bevy_ui_forms_form_proc
A bevy plugin for creating forms
-
gsfw-util
game server development utils
-
egdata-manifests-parser
A parser for Epic Games manifest files
-
gravitron_components
Gravitron's ECS Components
-
fps_counter
A Frames Per Second (FPS) counter
-
regecs-codegen
Code generation macros for REGECS
-
yarecs
Entity Component System
-
librollenspielsache
API for working with tabletop RPG entities
-
sustenet-master
Sustenet master server that accepts connections from cluster servers and clients. It also redirects clients to clusters.
-
android_base
A base for making android applications in rust with piston and glutin-window that simplifies android development
-
bevy_fighter
A mildly opinionated micro-engine for building 2D fighting games with bevy
-
legion-systems
High performance entity component system (ECS) library
-
newport
Modular Game Engine built in Rust
-
newport_os
Os abstractions for engine use
-
bevy_foliage_paint
A foliage painting system using warbler grass
-
dexterous_developer_builder
A modular hot reload system for rust
-
geon
once and for all!
-
nimble-rectify
Integration between assent and seer
-
renet_netcode
netcode transport for the renet crate: Server/Client network library for multiplayer games
-
bevy_quicsilver
QUIC transport protocol for bevy_ecs, using quinn_proto
-
entity_table_realtime
An ECS data store for realtime components
-
tw4f
A tiny and safe abstraction over the WASM-4 fantasy console
-
wasm4fun-storage
Storage primitives and subsystems for WASM-4 fantasy console
-
sprite
Procedurally generate pixel sprites and save them in different formats
-
covey_asset_loader
Bevy plugin for asset loading
-
micro_bevy_splash
one-shot logo splash screen for Bevy
-
ambient_api
The API to the Ambient Runtime
-
bevy_fabulous
A Bevy plugin for enriching spawned GLTF scenes with gameplay components / assets
-
sol-lang
Sol toolchain and library
-
bevy_spawn_fn
Awesome spawning experience for bevy
-
simple_ecs
A super-simple entity-component system in Rust
-
valence_inventory
Inventory support for Valence
-
bevy_simple_2d_outline
2D outline materials for the bevy game engine
-
blizzard-server
Blizzard Server Engine ❄️ is a solution for a TCP multiplayer server
-
mock-agones
Mock Agones SDK server for testing Agones integration
-
bevy_kot_misc
Miscellaneous prebuilt utilities for bevy_kot
-
include-shader
A macro for including shader files as string with dependencies support
-
vleue_sentry
Sentry reporting plugin for Bevy
-
bevy_assets_tar_zstd
Asset loader using .tar.zstd
-
bevy_arrows_plugin
A Bevy plugin for drawing arrows next to components. Very WIP
-
bevy_2d_box_physics
A 2D box-collision physics engine for use with the bevy engine
-
godot-codegen
Internal crate used by godot-rust
-
wrym_laminar
Laminar transport for wrym
-
appl
physics engine powered by the Rapier library. It is currently 2d only.
-
kudo
A minimalist Entity Component System. (Work in Progress)
-
fyroxed
A standalone scene editor for Fyrox game engine
-
entity_rust
Event driven CES framework for Rust with a macro DSL
-
magma_math
Part of the Magma-API, which is the API of the Magma3D game engine. This crate provides some convinient math.
-
bevy_tray_icon
Allows the use of tray-icon to manipulate the system tray
-
swamp-script-std
standard library for swamp
-
bevy_mod_plotters
A plotter material for bevy
-
parry2d
2 dimensional collision detection library in Rust
-
leafwing_input_manager_macros
Macros for the
leafwing-input-managercrate -
misc_ecs
basic Entity Component System library, being developed as a way to learn
-
renderling_build
Helper for compiling GLSL shaders for renderlings. To be used in build.rs files.
-
bevy_rapid_qoi
Bevy support for the QOI (Quite OK Image) format, based on rapid_qoi
-
bevy_serde_macros
Macros for easing use of serde on bevy entities and components
-
reactor_camera
A 2D camera plugin for Bevy, inspired by the Love2D camera plugin - STALKER-X
-
bevy-ui-debug-overlay
Debug overlay for Bevy UI
-
beet_spatial
Spatial actions built upon beet_flow
-
bevy_touch_stick
Bevy virtual touch joystick for mobile games
-
bevy_asset_manager
asset loading and organization in bevy
-
fyrox-ui
Extendable UI library
-
dexterous_developer_dylib_runner
A modular hot reload system for rust
-
specs-physics
nphysics integration for the Specs entity component system
-
limnus-loader
Loads assets for limnus
-
flecs_ecs_sys
sys binding for C/CPP flecs ECS library https://github.com/SanderMertens/flecs
-
bevy_eventwork
Event based networking library for Bevy
-
renderling_forward
A forward shading WGPU rendering pipeline
-
hedron
An all-in-one 3D modelling library
-
flat_commands
bevy ecs extension traits
-
vulk-gen
Vulkan bindings for Rust, except only the bleeding edge features
-
bevy_sprite
sprite functionality for Bevy Engine
-
recastnavigation-sys
Raw FFI bindings for recastnavigation
-
bevy_aoui_widgets
UI, events and dsl for the bevy_aoui crate
-
sheep_cli
Modular and lightweight spritesheet packer
-
ayaka-plugin-wasmer
A plugin runtime for Ayaka, based on Wasmer
-
bevy_dragndrop
implementing drag and drop functionality much easier for the bevy ECS engine
-
bevy_picking_raycast
A modular picking plugin for Bevy
-
bevy_event_set
A macro to create event bundles for Bevy
-
specs-blit
2D sprite rendering extension for the Specs ECS system
-
oxygengine-ha-renderer-debugger
Debugger for Hardware Accelerated renderer module for Oxygengine
-
bevy_mod_paramap
Parallax mapping shaders (relief and POM) for the bevy game engine
-
rapier_testbed3d
Testbed for the Rapier 3-dimensional physics engine in Rust
-
bevy_ui_3d
A UI plugin to enable 3d interactions
-
pleco_engine
A blazingly-fast Chess AI
-
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
-
bevy_keybind
Common event interface for bevy_input, so that we can better separate logic from configuration
-
oxygengine-overworld
RPG overworld module for Oxygengine
-
hexe
A chess engine
-
bevy_neosprite
Asset-driven sprite system built on top of Mesh2d
-
geng-ecs
Game Engine (ecs)
-
astral-error
Error handling library for the Astral Engine (WIP)
-
eccles
An Entity Component System in Rust focusing on speed and user-friendliness
-
reactor_proto
An opinionated rust library for transforming on-disk assets into Entities in Bevy
-
bevy_progress_bar
Easy ninepatch progress bar in bevy
-
aeronet_replicon
aeronetbackend implementation forbevy_replicon -
fna3d-sys
Rust FFI bindings to FNA3D
-
bevy_backroll
A Bevy engine integration plugin for the backroll rollback networking library
-
zengine_gamepad
gamepad functionality for ZENgine
-
flatbox_ecs
ECS functionality for Flatbox engine
-
entity_component
Entity and Component part of a full ECS
-
nimble-step
Nimble Step
-
bevy_procedural_vegetation
A procedural vegetation system for the Bevy game engine
-
mun_paths
convenience structures for handling relative- and absolute paths
-
bevy_scrolling_2d_camera
2d camera plugin for bevy supporting scrolling with right mouse dragging
-
bevy_sprite_material
Plugin to use materials for sprites
-
akashi
A framework for building collectible card games and gacha games
-
chess-lib
A chess movement generator library
-
wasm4fun-time
Time primitives and subsystems for WASM-4 fantasy console
-
tictactoe_menace_s
Tic Tac Toe game with a Menace AI
-
playdate-lua
High-level Lua API built on-top of Playdate API
-
bevy_vinox_pixel
A package for creating pixel games in bevy
-
com-croftsoft-lib-animation
CroftSoft Library for Animation
-
swamp-window
Easily create and manage windows across multiple platforms for game applications, leveraging the power of the
winitlibrary -
bevy_quill_obsidian_graph
A collection of widgets for implementing node-graph editors
-
bones_scripting
Official scripting integration with bones_framework
-
inexor-rgf-plugin-git
Inexor - Reactive Graph Flow - Plugin - GIT
-
yaecs
Entity Component System
-
bevy_tileset_core
Core of bevy_tileset
-
crankit-sys
Generated bindings for the playdate C API
-
enteum
Lightweight Entity Component System with Rust
-
bevy_ninepatch
Displays 9-Patch UI elements in Bevy
-
bevy_retro_camera
Scaled pixel-perfect rendering camera for Bevy
-
nuuro
A specialized 2D game library
-
tm-derive
FFI bindings for the machinery api
-
srs2dge-ecs
2D Game Engine
-
game_state_machine
A stack-based state machine with update functions
-
include_dir
Embed the contents of a directory in your binary
-
thrustengine
a 3d graphics engine
-
bevy_assetio_zip_bundler
An asset bundler for the bevy_assetio_zip crate
-
bevy_xml
An Sparrow SpriteSheet XML Parser for Bevy!
-
xvc-ecs
Entity-Component System for Xvc
-
qqx
3d library for rust based on OpenGL
-
fna3d
Wrapper of FNA3D
-
bevy_winit
A winit window and input backend for Bevy Engine
-
bevy_terminal_shader
An old school terminal shader for the bevy game engine
-
bevy-yoetz-macros
Supplemental macro crate for bevy-yoetz
-
bevy_cleanup
Cleanup design pattern tools for Bevy
-
bevy_manim
bevy plugin for drawing and animation
-
elaphos
An animation framework for bevy
-
reactor_core
A combined suite of tools provided by reactor for use with the Bevy game engine
-
aeronet_wt_native
Native WebTransport transport implementation for aeronet
-
bevy_despawn_with
Commands extension trait for despawning multiple entities
-
nuuro_build
A specialized 2D game library
-
bevy_auto_plugin
Procedural macros to simplify and streamline the creation of Bevy plugins by automating the registration of types, initialization of resources, and addition of events
-
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_picking
screen picking functionality for Bevy Engine
-
shipyard_hierarchy
Hierarchy for Shipyard Entity Component System
-
bones_input
Core input types for bones_lib
-
treasury-client
Client for treasury
-
bevy-animator
An animation library for Bevy that supports many animation formats and animation state machines
-
tinyecs
Tiny entity component system
-
yarnspinner_codegen
Code generation for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
bevy_mikktspace
Mikkelsen tangent space algorithm
-
hieu-chess
chess library that handles move generations, move validation, board representation and piece placements
-
hikaru
Download all games from Chess.com
-
terraformer3d
A 3d game engine for quantii
-
bevy_ui_borders
Bevy UI borders plugin
-
ecs_game_in_rust
Entity Compnent System map for games (a simple test for rust programming)
-
pistoncore-winit_window
A winit back-end for pistoncore-window
-
aspen-loader
multi-threaded asset loader for the aspen engine
-
vulk-ext
Vulkan bindings for Rust, except only the bleeding edge features
-
noise_rs
The perlin and simplex noise implementation in 2d and 3d
-
fyrox-impl
Feature-rich, easy-to-use, 2D/3D game engine with a scene editor. Like Godot, but in Rust.
-
ggez_tools
Some useful tools for ggez(i.e. state manager. You can also use my ui for ggez but it is super ugly though animation comming soon...)
-
parry2d-f64
2 dimensional collision detection library in Rust. 64-bit precision version.
-
bevy_retro_core
Pixel-Perfect, 2D Renderer and plugin set for Bevy that Seamlessly Targets Desktop and Web
-
bevy-ui-build-macros
A collection of macros to speed up the process of defining UIs in bevy
-
overworld_components
adding game systems useful for incremental and management games
-
check-buddy-pgn-parser
The PGN parser for check buddy
-
bevy_blockout
package that provides blockout utilities
-
bevy-add-events-macro
A macro to add multiple events to a bevy app easily
-
bevy_kindly
Minimalistic implementation of entity kinds for Bevy ECS
-
rapier3d-urdf
URDF file loader for the 3D rapier physics engine
-
limnus-gamepad-gilrs
Small wrapper around gilrs to provide gamepad abstraction
-
moshimoshi
A small crate to sugar working with command callbacks in bevy
-
tobj
A lightweight OBJ loader in the spirit of tinyobjloader
-
bevy_kot_ecs
ECS utilities for bevy_kot
-
swamp-wgpu-math
wgpu math types
-
static_ecs
static entity-component system
-
rshader
A simply library for reloading shaders at runtime
-
bevy_action_animation
Action-based animation system
-
dip_config
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
specs_declaration
macro to effectively create SPECS systems
-
gdnative-sys
Generated bindings to the Godot game engine's gdnative core types (See the gdnative crate)
-
dip_bundle
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
limnus-default-stages
limnus default stages,
First,PreUpdate,Update,PostUpdate, etc -
bevy_editor_pls_core
In-App editor tools for bevy apps
-
fyrox-template-core
Project template generator for Fyrox engine
-
wasm4fun-panichandler
Panic handler for WASM-4 fantasy console
-
luminol-audio
Luminol's audio backend
-
inexor-rgf-model-binary
Inexor - Reactive Graph Flow - Model - Binary
-
photon_decode
Set of utilities for decoding messages generated by photon framework
-
chess-lab
Chess library with multiple variants and FEN/PGN support
-
bracket-rex
Load/save REX Paint files and utilize them in bracket-terminal projects
-
include-fs
Embed folders in your binary
-
bevyhub_template
An example workflow for publishing Bevy apps and scenes to Bevyhub
-
flatbox_systems
ECS systems for Flatbox engine
-
bevy_asset_packer
Easy to use bevy plugin for packing resources in single file and protect him
-
mun_capi_utils
Common functionality between C api crates
-
parry3d
3 dimensional collision detection library in Rust
-
cgmath_dolly
Composable camera rigs but this time using CGMATH
-
nimble-blob-stream
Nimble Blob transfer over datagrams
-
constellation
A data-oriented entity component system optimized for cache coherent resource access and parallel system execution
-
pistoncore-event
flexible generic event threading
-
mangrove-save-detector
Detects file changes and sends message to mangrove script plugin
-
srs2dge-link-static
2D Game Engine
-
bevy-undo2
makes it easy to use the undo-operation on bevy
-
intuicio-framework-ecs
Entity-Component-System framework module for Intuicio scripting platform
-
space_persistence
Subcrate for the space_editor crate. Contains the persistence code for the space_editor
-
bevy_retrograde_audio
Bevy plugin for playing sounds
-
hecs-hierarchy
Hierachy implementation for Hecs ECS
-
oxygengine-network-backend-native
Network Native backend module for Oxygengine
-
nimble-client
Nimble Client
-
rafx-plugins
Rendering framework built on an extensible asset pipeline
-
friendly-chess
friendly neighborhood chess engine
-
bevy_mesh
mesh types for Bevy Engine
-
bevy_defer_http
Hyper based http utilies for bevy_defer
-
beet_rsx_parser
Tools for building reactive structures
-
ryot-assets-cli
CLI for managing assets from the Tibia client for Ryot
-
oat
A chess engine
-
aeronet_wt_core
Core types for the WebTransport implementations for aeronet
-
bevy_mini_fps
Quick and dirty FPS display for bevy
-
amethyst
Data-oriented game engine written in Rust
-
bevy_flair_core
Bevy UI styling using CSS
-
notation_bevy_utils
Fun notation - bevy utils
-
cuicui_layout_bevy_ui
Integration with bevy_ui for cuicui_layout
-
yarnspinner_core
Core concepts for Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
bevy_scene
scene functionality for Bevy Engine
-
shiv
modern Entity Component System
-
ayaka-plugin-wasmi
A plugin runtime for Ayaka, based on Wasmi
-
dexterous_developer_manager
A modular hot reload system for rust
-
sjakk
Chess movegen
-
bevy_enhanced_input_macros
Bevy Enhanced Input Macros
-
alcibiades
A framework for writing chess engines in Rust
-
pufferfish
An opinionated 2D game framework
-
bevy_picking_selection
A modular picking plugin for Bevy
-
png2wasm4src
Convert indexed PNG images to Rust source code for WASM-4 engine
-
bevy_easy_compute
An easy way to run compute shaders for Bevy
-
bevy_mops
Mesh Operations library for bevy
-
ayaka-bindings
WASM bindings of plugins written for Ayaka
-
bevy_ui_pointer_capture_detector
a Bevy plugin that detects when the mouse pointer is over a UI node
-
rapier_testbed2d
Testbed for the Rapier 2-dimensional physics engine in Rust
-
bevy_retrograde_physics
Physics utilities for Bevy Retrograde
-
bevy_dioxus
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
newport_cache
Cache Builder for Newport
-
bevy_simple_stat_bars
draw stat bars that follow sprites
-
crabfish
chess engine
-
limnus-log
Initializes logging
-
codegame
framework
-
astral-math
Math library for the Astral Engine (WIP)
-
rafx-resources
Rendering framework built on an extensible asset pipeline
-
luminol-config
Luminol's configuration
-
rox2d
2D physics engine heaviliy inspired by (the venerable) Box2D physics engine
-
bevy_retrograde_epaint
Epaint integration for rendering in Bevy Retrograde
-
zengine_graphic
graphic functionality for ZENgine
-
reactor_serial
A plugin for Bevy for handling saving and loading
-
piston-rect
Helper methods for computing simple rectangle layout
-
geng-draw2d
Game ENGine
-
wyrd
an entity component system created for TimberWolf
-
bevy_2delight_layers
2d camera layering and lighting system that's _delight_ful to use
-
ambient_debugger
Ambient debugger. Host-only.
-
vampirc-uci
A Universal Chess Interface (UCI) protocol parser and serializer. Part of the Vampirc chess suite.
-
bevy-kenney-assets
Use kenney spritesheets as texture atlases in Bevy
-
bevy_picking_highlight
A modular picking plugin for Bevy
-
bevy_ui_style_builder
Experimental Bevy UI helper extension methods
-
bevy-tnua-xpbd3d
XPBD 3D integration for bevy-tnua
-
bevy_mod_scripting_core
Core traits and structures required for other parts of bevy_mod_scripting
-
oxygengine-editor-tools
Editor tools for Oxygengine
-
oxygengine-integration-vn-ui
Integration module of visual novel and user interface for Oxygengine
-
bevy_system_reflection
reflecting systems, schedules, system sets and rendering schedules
-
bones_bevy_asset
Asset integration between bones_lib and Bevy
-
zengine_audio
audio functionality for ZENgine
-
bevy_windows_param
Bevy
SystemParamproviding a more ergonomic interface for accessing window-specific information, like resolutions and cursor positions -
cuicui_layout_bevy_sprite
Integration with bevy_sprite for cuicui_layout
-
flatbox_assets
assets management functionality for Flatbox engine
-
tanton_engine
A blazingly-fast Chess AI
-
inexor-rgf-model-value
Inexor - Reactive Graph Flow - Model - Value
-
bevy_kot_utils
ECS utilities for bevy_kot
-
bevy_extern_events
Bevy plugin for generic external events to be send to bevy EventReaders
-
mun_runtime
A runtime for hot reloading and invoking Mun from Rust
-
srs2dge-link-dynamic
2D Game Engine
-
bevy_mod_scripting_rune
Necessary functionality for Rune support with bevy_mod_scripting
-
nimble-layer
Nimble Layer
-
dexterous_developer_internal
A modular hot reload system for rust
-
mun_project
convenience structures for Mun projects
-
limnus-stage
Limnus stage that holds a vector of systems
-
bevy_text
text functionality for Bevy Engine
-
bevy_chair
Chair mesh asset loader plugin
-
bevy_hsl_multiplier
Multiply texture values in HSL color space
-
swamp-app-examples
examples for swamp-render
-
wasm4fun
Primitives and constants from WASM-4 fantasy console
-
calx-ecs
Serializable entity component system for games
-
dip_desktop
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
newport_game
that provides general game state for making games on
-
dotrix_ecs
Entity Component System implementation for Dotrix game engine
-
mevy_ecs
bevy_ecs macros, simplifying child spawning and picking!
-
darkengine
2D game engine written in Rust
-
nimble-host
Nimble Host
-
limnus-scheduler
Limnus Scheduler trait
-
limnus-wgpu-window
creating and managing a window with rendering surfaces using winit and wgpu
-
hydrate-loader
Game asset pipeline and authoring framework
-
bevy_dev_tools
Collection of developer tools for the Bevy Engine
-
assets_manager
Conveniently load, cache, and reload external resources
-
blunders-engine
UCI chess engine core
-
psyche-core
Core module for Psyche AI Toolset
-
bevy_missing_texture
help with missing textures in bevy
-
bevy_retro_physics
Physics utilities for Bevy Retro
-
bevy_web_asset
Implementations for http(s) asset sources for Bevy
-
overworld_affinity
Overworld Affinity Library - Affinity and Multipliers
-
openlegends-core
Game Core for OpenLegends Card Game
-
siege
Render pixel art siege engines
-
ayaka-plugin-wasmtime
A plugin runtime for Ayaka, based on Wasmtime
-
bevy_diagnostic
diagnostic functionality for Bevy Engine
-
bevy_image_config
Bevy plugin that automatically configures image assets when they load
-
ecs-lib-rs
An Entity Component System (ECS) Framework for learning
-
bevy_fmod
Idiomatic FMOD in Bevy
-
pretzel
2D rendering 🥨
-
component_table
Data structure for associating data with entities in an Entity Component System
-
bevy_ui_exact_image
Bevy UI image widget with more control over the size of images and their orientation
-
guimcaballero/bevy_chess
Chess demo in Bevy
-
newport_asset
Thread safe asset manager for Newport engine
-
ryot_core
Core functionality crate for the Ryot framework, housing essential components and systems foundational to game development
-
bevy_picking_input
A modular picking plugin for Bevy
-
rustengine
Rust bitboard multi variant uci chess analysis engine
-
geng-audio
Game ENGine
-
limnus-window-runner
winit runner for limnus-app
-
bevy_gilrs
Gamepad system made using Gilrs for Bevy Engine
-
bones_ecs
flexible Entity Component System
-
zengine_physics
physics functionality for ZENgine
-
flecs-sys
low-level bindings to the Entity Component System (ECS) framework flecs
-
oxygengine-navigation
Navigation module for Oxygengine
-
beet_net
A very flexible AI behavior library for games and robotics
-
geng-shader
Game ENGine
-
blue_engine_utilities
Blue Engine
-
range
addressing
-
bevy_register_in_world
Register types into the world during runtime
-
bevy_ss_anim
Animated-Sprite From Sprite-Sheets Generated In Adobe Animate
-
godot-core
Internal crate used by godot-rust
-
zengine_window
windowing functionality for ZENgine
-
rafx-nodes
Rendering framework built on an extensible asset pipeline
-
nimble-client-logic
Nimble Client Logic
-
mun_skeptic
ability to test Mun code snippets in an mdbook
-
nimble-protocol
Nimble Protocol
-
noframe
Game development framework using crate ggez
-
gecs
A generated entity component system
-
bones_framework
The Bones game development framework
-
lightyear_macros
Procedural macros for the lightyear networking library
-
bevy_eventlistener_core
Event listeners and callbacks for bevy
-
nphysics3d
3-dimensional physics engine in Rust. This crate is being superseded by the rapier3d crate.
-
limnus-scheduler-runner
Runs limnus schedulers
-
dip_cli
Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust
-
hydrate-data
Game asset pipeline and authoring framework
-
nimble-wrapped-step
Nimble Wrapped Steps
-
mireforge-font
Font asset loading
-
moonshine-core
Unconventional framework for making games in Bevy
-
amethyst_ecs
Entity component system (ECS) library
-
newport_editor
Editor for Newport engine
-
wasm4fun-log
Logging functions and macros for WASM-4 fantasy console
-
mun_language_server
language server protocol server for the Mun language
-
rapier_testbed3d-f64
Testbed for the Rapier 3-dimensional physics engine in Rust
-
piston-shaders
Shaders for game development in Rust
-
luminol-term
Luminol's in-built terminal
-
dragon
3D/2D game engines implemented with ECS concepts
-
mireforge-material
image asset loading and material creation
-
bevy_cameraman
2D camera for bevy
-
bevy_pathmesh
Navmesh plugin for Bevy
-
goods-treasury
Database for "goods" asset pipeline
-
async-ecs
Async Parallel Entity Component System for Rust
-
ambient_api_core
The API to the Ambient Runtime (core)
-
oxygengine-input
Input module for Oxygengine
-
chess-core
A chess engine that stands on its own
-
mireforge-render
standard render types for 2D
-
geng-camera
Game ENGine
-
zero_ecs_macros
Procedural macros for Build scripts for: ZeroECS: an Entity Component System (ECS), using only zero-cost abstractions
-
mireforge-advanced-game
advanced game (logic, render, audio)
-
oxygengine-script-web
Web scripting module for Oxygen Engine
-
goshawk
An RTS camera for bevy
-
bevy_awesome_debug_camera
customizable drop-in free cam for the (awesome) bevy engine
-
siege-editor
Pixel art siege engine editor/animator/creator
-
bevy_dynamic_plugin
dynamic plugin loading capabilities for non-wasm platforms
-
newport_gpu
Thread safe render abstraction layer for Newport engine
-
swamp-render
standard render types for 2D
-
ayaka-bindings-types
Types both used in Ayaka runtime and Ayaka plugins
-
bevy_input_focus
Keyboard focus management
-
bones_bevy_utils
using Bones with Bevy
-
newport_ecs
Custom ECS made for Newport
-
oxygengine-physics-2d
2D physics module for Oxygengine
-
bevy_picking_ui
A modular picking plugin for Bevy
-
mangrove-script
Swamp Script plugin for Mangrove
-
mireforge-game
common mireforge game types
-
zengine_input
input functionality for ZENgine
-
three-d-asset
Load/save functionality for 3d applications
-
psyche-amethyst
Amethyst game engine integration for Psyche AI Toolset
-
inexor-rgf-model-state
Inexor - Reactive Graph Flow - Model - State
-
bevy_picking_egui
A modular picking plugin for Bevy
-
bevy_yarnspinner_demo
A demo for Bevy Yarn Spinner for Rust, the friendly tool for writing game dialogue
-
mireforge-boot-advanced-game
boot up an advanced game (logic, render, audio)
-
goods-treasury-import
"Treasury" API for importers
-
piston3d-gfx_voxel
A voxel rendering library on top of Gfx
-
bevy_dylib
Force the Bevy Engine to be dynamically linked for faster linking
-
hydrate-base
Game asset pipeline and authoring framework
-
inexor-rgf-model-numeric
Inexor - Reactive Graph Flow - Model - Numeric
-
bevy_sprite_grid
draws sprites in a grid
-
swamp-script-types
types used in Swamp
-
renderling_core
Types shared by renderling pipelines
-
vecmath
type agnostic library for vector math designed for reexporting
-
swamp-asset-registry
keeps track of asset lifetimes
-
mun_vfs
in-memory filesystem
-
limnus-examples
examples for the limnus game engine
-
edict-proc
Powerful entity-component-system library
-
swamp-message
message container
-
beet_ecs
A very flexible AI behavior library for games and robotics
-
oxygengine-utils
module for Oxygengine
-
bevy_picking_sprite
A modular picking plugin for Bevy
-
mun_libloader
Functionality for loading Mun libraries
-
luminol-result
Luminol's custom error type
-
bevy_mod_ui_independent_text
Bevy UI text with a transform independent of the UI's layout
-
oxygengine-integration-ow-ha
Integration module of RPG overworld and Hardware Accelerated rendering for Oxygengine