Entertainment at it's peak. The news is by your side.

This Month in Rust GameDev #14 – September 2020


Welcome to the 14th wretchedness of the Rust GameDev Workgroup’s
monthly newsletter.
Rust is a systems language pursuing the trifecta:
safety, concurrency, and trek.
These desires are nicely-aligned with sport building.
We hope to assemble an gripping ecosystem for any individual wishing
to utilize Rust of their building route of!
Are looking out to bag alive to? Join the Rust GameDev working neighborhood!

You can apply the newsletter advent route of
by staring at the coordination components.
Need one thing talked about within the next newsletter?
Send us a pull search info from.
Feel free to ship PRs about your possess tasks!

Table of contents:

Game Updates 


LandscapeDeer by the riverside

Veloren is an commence world, commence-source voxel RPG impressed by Dwarf
Fortress and Dice World.

In September, Veloren hit 5000 commits to the first repo! A privilege escalation
malicious program became stumbled on within the game. It became immediate patched, and a PSA became sent out to
utter server householders of its presence. A Discord bot became created to lend a hand space up a
trying out server. Airshipper, Veloren’s launcher, noticed the originate of version
0.4.0. Many of work is occurring to present a boost to the convey of Veloren’s server
infrastructure. A stress test became rush with 15 avid gamers to detect how smaller server
might well handle running the game.

Enhancements had been made to the chunk compression which resulted in a ~7x memory
low cost of their storage. The settings menu has been overhauled, in conjunction with
many diverse sides of the UI. A stone golem boss became merged, collectively with a brand original boss
to dungeons. Work has been performed on beam weapons and collisions, leading to a
vastly improved therapeutic sceptre.

You can read more about some state matters from September:

September’s corpulent weekly devlogs: “This Week In Veloren…”:

Healing sceptreA reprise from trying at evening

In October, Veloren can lend a hand pushing in direction of more scalable infrastructure.
Tests are going down to pass in direction of a Kubernetes cluster to lend a hand an eye on more
infrastructure from code. Optimizations can lend a hand coming in as we discover areas to
give a boost to. 0.8 might originate within the future this month, nonetheless, the state date is yet to
be space.

A/B Avenue 

Isometric buildings and textured areas

A/B Avenue is a traffic simulation sport exploring how small modifications
to roads impact cyclists, transit users, pedestrians, and drivers. Any city
with OpenStreetMap coverage might well even be extinct!

Some of this month’s updates:

  • carried out enhance for riding on the left facet of the boulevard;
  • isometric constructions and enhance for textures by Michael;
  • a flurry of predominant UI updates, due to return of the project’s UX
  • an likelihood to disable parking simulation, to workaround missing recordsdata;
  • alleyways imported from OSM;
  • more realistic traffic signal timing constraints, because of
    Sam, a brand original contributor.


screenshot: trees and water

Backyard is an upcoming sport centered round rising realistic vegetation.
Some of the updates from the September devlog:

  • The project switched to Nvidia’s PhysX from a custom physics engine.
  • Extra moral plant clone placement.
  • Principal rendering performance enhancements.
  • Work on saving and loading diagram has begun.



galangua by @tyfkda is a dynamic 2D shoot ’em up sport,
written in Rust utilizing SDL2.
It genuinely works on the desktop besides within the browser.

The source code is on hand here.

Methodology of Rhea 

Way of Rhea logo

Methodology of Rhea is a puzzle platformer that takes convey in a world the build you per chance might
powerful work in conjunction with objects that match your present color.
Changes since the final replace:

  • The circuit level has been remodeled:
    or now not it’s now split into three diverse stages
    and the puzzles are higher tutorialized, and there are more of them.

  • A little quantity of veil veil shake became added to the game.

  • Work has begun on just a few recent stages for the ice biome
    In this biome, you enjoy to be taught to predict the behavior of the
    crabs to resolve the puzzles.

    Ice Biome

Adjust to @AnthropicSt or @masonremaley on Twitter or
be a part of the mailing listing for updates.


Live editing of procedural architecture rules

Citybound is a city simulation and city building sport. This month,
Anselm Eickhoff published a small demo of his domain state language
for procedural structure, which is interpreted by Rust and now helps
hot-code reload of establishing solutions within the running sport.

Cope with Singularity 

Demo of the basic ship collisionA ray-traced different of modules

The Cope with Singularity is a sport about designing independent manufacturing unit ships and
stations created by Tom Leys.

This month a brand original devlog became posted:
“Cope with Singularity in Sep 2020”.
You can additionally look at out a role replace and growth video here.

Updates consist of:

  • Bettering the robustness of the game core and networking.
  • Ship sections and standalone ships.
  • Loads of synchronization algorithms for diverse sport modes.


Mimas screenshot

Mimas is a WIP voxel engine and sport, impressed by Minetest and Minecraft.
Or now not it’s been in building for nearly 2 years and has now not too prolonged within the past seen a public
prototype originate 0.4.0.

Several of the urrent parts:

  • Procedural diagram generation with hilly landscape, bushes, flowers, water, and caves
  • Procedure manipulation (removal/addition of blocks)
  • Crafting
  • Chests
  • Textures (taken from the Minetest project, beneath CC-BY-SA license)
  • Instruments
  • QUIC based network protocol with SRP based authentication
  • Multiplayer: chat, (hardcoded) avatars
  • Capacity to add custom vow (e.g. blocks) utilizing a toml layout

Imgur screenshot gallery.

Nox Futura (Rust Version) 

Gameplay screenshots

Nox Futura by @blackfuture
is an commence-source prolonged-timeframe ardour project,
a Dwarf-Fortress and RimWorld impressed deplorable building sport.

Some of the recent updates:

  • The WGPU-based rendered is undergoing a predominant restructure.
  • The game became updated to Legion 0.3 – it required rewriting a selection of code,
    nonetheless the original syntax sugar is a pleasure to utilize, and the backend is even sooner now.
  • The Grasping Voxel algorithm became vastly improved.
  • OBJ models are now supported – pleasurable for issues like tree/vegetation geometry,
    which is ready to now use a stylized low-poly graphic with out the added weight
    of a bunch of cubes.
  • Palette-based rendering – the output diagram is now constrained
    to a 256 color palette, largely to play with stylized 3D rendering.
  • Contemporary layout for recordsdata recordsdata that combines multiple RON objects in one convey.


pGLOWrpg banner

The @pGLOWrpg (Procedurally Generated Living Originate World RPG) is a prolonged-timeframe
project in building by @Roal_Yr, which objectives to be a text-based sport with
most portability and accessibility and point of interest on interactions and emergent

The pGLOWrpg meets its first adequate anniversary on September the 15th
and goes public at pGLOWrpg repo!

For the past month the first point of interest of the reach became on:

  • Bettering the UI.
  • Major refactoring.
  • Unification of I/O contrivance.
  • Making issues ready for e-newsletter.

Considerable parts of the reported version are:

  • Capacity to generate one or many worlds from customizable presets.
  • Capacity to enjoy output in each uncooked (b/w .png) and colorized photography.
  • Generated recordsdata is as follows: terrain, watermask, biomes, rivers, geological regions,
    rainfall, and temperature.

For most fundamental operate reviews and dev blogs apply @pGLOWrpg on Twitter.

Oh no, Lava! 

shooting water into lava

“Oh no, Lava!” by @captainfleppo is the working title
of a platforming sport which use inspiration
from an old iOS sport created lend a hand in 2014. The game is running with Bevy
as its core. The gameplay is now not there yet, nonetheless you as a player deserve to leap on
furnitures, accumulate cash, and fight lava/fire based enemies with your water gun.


Summoner imps throw a swordsman aroundBe cautious with chained response attacks!

Zemeroth by @ozkriff is a minimalistic 2D turn-based tactical sport.
Some of the hot updates:


Akigi is a WIP on-line multiplayer sport.
In September, a full bunch work became performed on terrain sculpting systems. But any other software
became added, allowing subject topic painting onto the terrain. At the side of the scenery
placement software, there are now three separate tools within the editor’s arsenal.

Full devlogs:


Play Go against AI and friends on the webPlaying KataGo AI in 9×9

BUGOUT is a web utility which helps you to play Ride/Baduk/Weiqi
towards a number one AI (KataGo).
It affords a multiplayer mode so that you just per chance might play diverse folks,
either by joining a public queue or sharing a inner most URL to your friend.

The person interface is lifted from Sabaki.

The preliminary installation’s AI is powered by an vitality-efficient
dev board.

BUGOUT is marching actively in direction of production, at which point the
group will put up the accumulate convey handle and invite users.
The creator anticipates being carried out with the production originate
earlier than Jan 1, 2021.

Tetris Bane 

Tetris Bane

Tetris Bane is an commence-source Tetris clone
that mixes issues up with multiple sport modes.
There’s a exhausting bane mode, classic mode for the purists,
ultra exhausting steel mode, and a sit down again mode.
Tetris Bane challenges you to bag more then 2 traces in steel mode.

You can bring collectively the game for Home windows, macOS and Linux.

The game is written utilizing rust-sdl2.
The source code is on hand here.

Mission YAWC 

Screenshot of an in-progress game of Project YAWC

Mission YAWC is an in-growth Attain-Wars sort contrivance sport being developed
by junkmail utilizing ggez as a framework. The game is currently in a closed alpha
convey with working netplay. September noticed the originate of version A2, collectively with
revamped netcode and the corpulent core space of objects.



space_shooter_rs is a 2D shooter sport made with the Amethyst sport engine.
It is miles impressed by video games like Raiden and the Binding of Isaac.

In September, Micah Tigley joined the project and has been taking part with
Carlo Supina to refactor a fundamental chunk of the codebase. Many of work has
been on collision detection, fight, and plug. This is able to permit for more uncomplicated
future building.

Both developers wrote relating to the work and their experiences increasing space_shooter_rs:

Studying Field fabric Updates 

So You Are looking out to Are residing-Reload Rust 

cool bear with glassesCool endure

@fasterthanlime published a large blog post
“So that you just need to are residing-reload Rust”
– a truly deep technical dive into reloading a dylib
and a bunch of linked components.
Many of attention-grabbing insights for of us who desire
to higher trace nuances of hot reloading.



rust-wasm-hotreload by @ShekoHex is a PoC of utilizing WebAssemply
as a hot-reloadable code logic at runtime with out restarting the host route of.
Ascertain out a video demo here.

Be taught WGPU 

This month @sothr released one other chapter
of the “Be taught WGPU” tutorial:
“Threading WGPU Helpful resource Loading with Rayon”.

Also, your total tutorial became upgraded to WGPU v0.6.

Is It Easy to Scheme a Line? 

hexagonal strategy map with region bordersInstance of result chains.

A small expose by @VladZhukov0 about drawing traces and chains
with signed distance fields.
The resulted traces are fine taking a look on edges and revel in rounded corners.
Chains for this article are assumed to be opaque.

Ascertain out the on-line demo
and its source code.

OpenGL Preprocessor for Rust 

With the corpulent energy of Cargo assemble scripts and Tera, you per chance might fabricate a cosmopolitan
GLSL preprocessor which is ready to generate code conditionally, in loops, and even
inherit code from diverse templates.

An OpenGL preprocessor for Rust

Writing undeniable GLSL code is unhappy, code is rather typically is duplicated, libraries
are now not one thing natural for GLSL (contrivance you per chance can now not out of the box attain #consist of “library.glsl”).
The final point is severely problematic if some constants genuinely bag in
your sport logic (just like the different of player sorts). Updating these values manually
for your shader code is repetitive and inclined to each error and simple forgetfulness.
Or now not it’s genuinely indispensable to assemble some more or much less preprocessor for your GLSL code,
which is ready to consist of diverse recordsdata, so that you just per chance might space up your code into manageable chunks.
With the energy of Tera, or now not it’s now easy to full.
Because Rust is additionally typically extinct for web tasks, which want a selection of templated
web-pages preprocessing, we can borrow such skills for our wants,
combine it with cargo assemble scripts and fabricate a bring collectively-time preprocessing software.

Rust, Gamedev, ECS, and Bevy 

Bevy hello world code snippet and two game screenshots, one displaying two blue spheres in a grey canvas and another one displaying a gameboy colored tile game

@hugopeixoto released just a few blog posts on ECS and Bevy,
collectively with an academic on how to start.

  • The first allotment affords us an intensive overview of what ECS.
    It begins with pseudocode for an object oriented contrivance
    and goes through various iterations until we bag to the ECS paradigm.

  • The 2d allotment is an academic on how to utilize bevy,
    an info pushed sport engine built in Rust.
    It goes over the classic parts of the engine,
    utilizing the example presented within the first allotment.

Flappy Fowl in Bevy 

tantan preview

@TantanDev is lend a hand with one other video!
In this one, they made a Flappy Fowl clone utilizing Bevy
and shared their ride programming with it.

The source code might well even be stumbled on here.

Steady-Time Global Illumination in WGPU 

Endless light bounces in Cornell Field

DI2edd shared his accurate-time diffuse world illumination demo on /r/rust_gamedev.
Or now not it’s written in 100% Rust and uses WGPU for graphics, proving that the API
is an powerful different even for progressed computer graphics capabilities.

The methodology affords accurate time world illumination for static lambertian
geometry, and is the implementation of the 2017 paper “Steady-time Global
Illumination by Precomputed Local Reconstruction
from Sparse Radiance Probes”
which proposes a spherical harmonics-based technique to resolve the rendering equation
in accurate time.

In practice, this contrivance that the dear light transport calculations are performed
in a precomputation step, which relies on – amongst others – embree-rs,
and nalgebra to diagram a compressed
illustration of the scene that’s then extinct for lighting fixtures reconstruction at runtime.

legion v0.3 


Legion is amongst Rust’s fastest and strongest ECS libraries.
After months in building, v0.3 has in the end been released to
It is miles a perfect originate amounting to a near total rewrite of the library
and a predominant step in direction of a fetch 1.0 originate.

Ascertain out the v0.3 announcement post
for a high level diagram of the original API and your total updates.

The project’s repo has additionally been moved to the Amethyst org
to copy its discontinuance collaboration with the Amethyst community.



Thunderdome is a gladitorial generational enviornment library impressed by
generational-enviornment, slotmap, and slab. It affords fixed time
insertion, search for, and removal through small (8 byte) keys that place 8 bytes when
wrapped in Option.

Recordsdata structures like Thunderdome’s Arena retailer values and return keys that might
be later extinct to entry these values. These keys are fetch all the intention through removals and
enjoy a generation counter to resolve the ABA Peril.

let mut enviornment = Arena::original();

let foo = enviornment.insert("Foo");
let bar = enviornment.insert("Bar");

assert_eq!(enviornment[foo], "Foo");
assert_eq!(enviornment[bar], "Bar");

enviornment[bar] = "Modified";
assert_eq!(enviornment[bar], "Modified");

let foo_value = enviornment.use away(foo);
assert_eq!(foo_value, Some("Foo"));

// The slot beforehand extinct by foo might be reused for baz.
let baz = enviornment.insert("Baz");
assert_eq!(enviornment[baz], "Baz");

// foo is now not any longer a legit key.
assert_eq!(enviornment.bag(foo), None);



Fontdue is a easy, no_std, pure Rust, TrueType & OpenType
font rasterizer and layout software.
It strives to assemble interacting with fonts as immediate as that you just per chance might believe,
and currently has the bottom slay to slay latency for a font rasterizer.

Fontdue is reckoning on ttf-parser for parsing fonts,
which helps a huge differ of TrueType and OpenType parts.

A non-aim of this library is to be allocation free and revel in a immediate,
“zero mark” preliminary load.
Fontdue does assemble allocations and is reckoning on the alloc crate.
Fonts are completely parsed on advent and relevant recordsdata is saved
in a more convenient to entry layout.
In contrast to diverse font libraries, the font structures have not any lifetime dependencies
since it allocates its possess space.

Mission’s roadmap:

  • v1.0: fontdue is designed to be an alternative choice to
    rusttype, ab_glyph, substances of glyph_brush, and glyph_brush_layout.
    It is miles a class of font libraries that manufacture now not deal with shaping.
  • v2.0: Shaping – the advanced layout of text equivalent to Arabic and Devanagari
    – might be added.
    There are two capacity pure Rust libraries (allsorts or rustybuzz)
    that are candidates for providing a shaping backend to Fontdue,
    nonetheless are comparatively immature lawful now.

Discussions: /r/rust

ultraviolet v0.6 

ultraviolet by @fu5ha is a crate for computer-graphics
and video games-linked linear algebra, nonetheless immediate,
each in the case of productiveness and in the case of runtime performance.

This month ultraviolet v0.6 became released.
Updates consist of:

  • Reinforce for 256-bit huge AVX vectors and directions
    besides 128-bit huge SSE instructions which had been already supported.
  • Reinforce for f64/double precision floats beneath the f64 operate,
    collectively with f64x2 and f64x4 SIMD-accelerated sorts.
  • Reinforce for mint for most scalar sorts.
  • Many of smaller API and performance enhancements.


This Month in Mun 

Mun logo

Mun is a scripting language for gamedev targeted on like a flash iteration cases
that’s written in Rust.

September updates consist of:

  • on-going work for multi-file tasks;
  • assemble pipeline enhancements;
  • malicious program fixes within the Mun compiler and C++ bindings;
  • a selection of refactors and fine of life enhancements.


audir is a low level audio library supporting Home windows (WASAPI), Linux (Pulse)
and Android (OpenSLES & AAudio).

It objectives at providing a minimal and largely unsafe nonetheless operate-nicely off API on high of
customary audio backends with point of interest on gaming capabilities. The preliminary originate
version 0.1.0 affords customary recording and playback enhance for all on hand
backends, collectively with a small song player example!

In the interim taking a look into coupling with dasp for dsp audio graphs to produce
a elevated level entry point.


Crevice is a library that helps clarify GLSL-like minded (std140) structs for
use in uniform and storage buffers. It uses original const fn capabilities
stabilized in Rust 1.46.0 to align sorts with explicitly zeroed padding.

Crevice is dependent carefully on mint to enhance nearly any Rust math library. It
additionally comprises helpers for safely sizing and writing buffers, making dynamic
buffer layout a trot.

struct MainUniform {
    orientation: mint::ColumnMatrix3<f32>,
    space: mint::Vector3<f32>,
    scale: f32,

let mark = MainUniform {
    orientation: cgmath::Matrix3::identity().into(),
    space: [1.0, 2.0, 3.0].into(),
    scale: 4.0,





FemtoVG is a 2D canvas API in Rust, according to nanovg.

In the interim, FemtoVG uses OpenGL as a rendering backend. A Steel backend is 95%
performed, and a wgpu backend is on the roadmap. The project is for sure taking a look
for contributors.

In contrast to NanoVG, FemtoVG has corpulent text-shaping enhance because of harfbuzz.

FemtoVG, accurate just like the distinctive NanoVG, is according to the stencil-then-cowl
contrivance presented in GPU-accelerated Route Rendering.

Join the Discord channel
or apply FemtoVG on twitter.

gfx-rs and gfx-portability 

gfx-rs logo

gfx-portability is a Vulkan portability implementation according to gfx-rs.
Or now not it’s in general a tumble-in implementation of Vulkan on high of Steel and D3D12,
pleasurable on platforms that manufacture now not enjoy native Vulkan enhance, or enjoy buggy drivers.

It released version 0.8.1
with adequate enhance for the original KHR portability extension,
besides some diverse extensions, plus a different of correctness fixes.

gfx-rs group asks Rust users of Vulkano, Ash, and diverse Vulkan-powerful wrappers to try
out the gfx-portability as a solution on macOS and relevant Home windows 10 platforms.

In gfx-rs itself, the DX12 backend, and the descriptor indexing operate enhance
obtained improved. There has been a push to bag DX11 backend in a fetch shape,
and it would now rush vange-rs moderately nicely 🎉.


Riddle is a Rust media library within the vein of SDL,
building as a ways as that you just per chance might believe on basically the most active/bizarre Rust libraries
(winit, wgpu, describe, and so forth). Riddle is deliberately now not an engine, or a framework.
It is miles a library dedicated to exposing media linked parts in a unified formula while
averting prescribing program structure. It affords abstractions over windowing,
enter, audio, describe loading/manipulation and affords a customary wgpu based 2D
The docs maintain runnable examples for most strategies and sorts.

The aim is to produce a fetch foundation, resilient to traits within the Rust
gamedev ecosystem, on which video games, custom engines, and diverse media capabilities can
be built.



bracket-lib (beforehand rltk_rs) by @blackfuture
is a Rust implementation of C++ Roguelike Toolkit.

Bracket-lib is going through a stability pass, focusing on freezing the API.
This is able to perhaps even be featured within the creator’s upcoming e book:
Fingers-on Rust: Effective Studying through 2D Game Pattern and Play.
The e book wants to be going into early entry/beta in time for the next newsletter.


Video games built with miniquad/macroquad.

macroquad by @fedor_games is a foul-platform
(Home windows/Linux/macOS/Android/iOS/WASM)
sport framework assemble on high of miniquad.

This month 0.3 preview became released, featuring:

Also, @now not-fl3 (the first developer of all present *quad tasks)
has been added to the GitHub Sponsors.
Ascertain out the project’s story, imaginative and prescient, and roadmap
on the original sponsors web page!


Tetra is a easy 2D sport framework, impressed by XNA and Raylib. This month,
version 0.5 became released, featuring:

  • Cargo operate flags, allowing you to use away unused functionality and
    shrink your assemble
  • Relative mouse occasions and countless mouse plug (taking into consideration FPS-sort
    lend a hand an eye on schemes)
  • Additional strategies for getting and surroundings the convey of a taking part in sound

For corpulent details and a listing of breaking modifications, discover the changelog.

Additionally, this month puppetmaster released tetrapack, a local of pleasurable
extensions for Tetra. This entails:

  • Priceless timer sorts
  • Looping background song
  • Custom mouse cursors
  • Enter utility capabilities
  • Tilemaps and tile animations

Bevy Engine v0.2 

bevy logo

Bevy is a refreshingly easy recordsdata-pushed sport engine built in Rust.
It is miles free and commence source forever!

This month, because of 87 contributors, 174 pull requests, and their
superior sponsors, Bevy 0.2 became released. You can gaze the
corpulent Bevy 0.2 announcement here. Here are some highlights:

  • Async Project System: Bevy now has a designate original async-powerful task diagram,
    which enables the appearance of context-state task pools. For instance, you may perhaps well per chance
    enjoy separate pools for compute, IO, networking, and so forth. This additionally affords the
    flexibility to load stability work because it may perhaps perhaps per chance perhaps be according to work style and/or precedence.
    This original task diagram fully replaces Rayon and the cpu utilization wins had been powerful!
  • Initial Net Platform Reinforce: (A subset of) Bevy now runs on the accumulate utilizing
    WebAssembly/WASM! Particularly, Bevy apps can rush Bevy ECS schedules, react to
    enter occasions, fabricate an empty canvas (utilizing winit), and just a few diverse issues. This
    is a perfect first step, nonetheless it’s severe to call out that there are quiet a
    different of missing pieces, equivalent to 2D/3D rendering, multi-threading, and sound.
  • Parallel Queries: Systems that use queries already rush in parallel,
    nonetheless ahead of this exchange the queries themselves couldn’t be iterated in parallel.
    Bevy 0.2 adds the capacity to with out considerations iterate queries in parallel, which builds on
    high of the original Async Project System.
  • Transform System Rewrite: Bevy’s old rework diagram extinct separate
    Translation, Rotation, and Scale substances as the “source of reality”,
    which had been then synced to a LocalTransform factor after every replace. There
    are Lawful Causes™ to utilize this contrivance, nonetheless it created a “walk” between the
    calculated LocalTransform and the source substances and dataflow between substances
    is exhausting to motive about. This wretchedness became resolved by making a newer, more smart
    rework diagram that uses a consolidated Transform style.
  • Joystick/Gamepad Enter: The Bevy Enter plugin now has dreadful-platform enhance
    for most controllers due to gilrs library!
  • Bevy ECS Performance Enhancements: generational entity IDs,
    read-powerful queries, lock-free world APIs, squawk factor search for.

Community plugin updates:

  • bevy_rapier:
    Rapier Physics’ adequate Bevy plugin became updated to enhance Bevy 0.2.
  • bevy_ninepatch:
    Record 9-Patch UI sides, the build you per chance might specify how
    diverse substances of a PNG must quiet develop.
  • bevy_mod_picking: 3d cursor
    selecting and highlighting.
  • bevy_contrib_colors:
    A easy color library.
  • bevy_input_map:
    Converts person inputs from diverse enter hardware into sport state actions.
    Ex: keyboard “Space” or joystick “A” might well even be mapped to a “Soar” Circulation.
  • bevy_prototype_lyon:
    Scheme 2D shapes, like triangles, circles, and beziers.
  • bevy_contrib_inspector:
    Visually edit fields of your bevy resources in a browser or native gaze.

hacker news,


a scene with lightning and a hi-poly character model
Click on to ogle a video demo of 1 in all the original examples.

rg3d is a sport engine that objectives to be easy to utilize and provide large space
of out-of-box parts. Some of the hot updates:

  • Render to texture – it’s that you just per chance might believe to render scenes into textures.
  • Added enhance for scenes made in rusty-editor.
  • Added sprite graph node.
  • Added easy lightmapper (quiet WIP).
  • Added original UI widgets and parts:
    • Message box – classic message box with diverse combos of buttons.
    • Wrap panel – arranges its kids by rows or columns with wrapping.
    • File browser – a browser for file diagram.
    • Coloration picker – classic HSV+RGB+Alpha color picker.
    • “Bring into gaze” for scroll panel.
    • Modified font rasterizer by fontdue.
    • Improved hotkeys in text box.
  • Improved performance and documentation.

Join the rg3d’s Discord channel
or apply Dmitry Stepanov on twitter.


rusty editor

rusty-editor is a scene editor for the rg3d engine.
Some of the now not too prolonged within the past added parts:

  • asset browser + asset previewer,
  • multiselection,
  • improved properties editor,
  • a full bunch diverse small enhancements and fixes.

godot-rust v0.9 

cute logo

godot-rust affords high-level Rust bindings
to the Godot sport engine.

This month v0.9 became released.
Besides a full bunch fine-of-life enhancements, this replace brings a large
redesign of the API in convey to resolve prolonged-standing soundness considerations.
As there’re varied breaking modifications,
a chapter about migration from 0.8 became added
to the person info.

Requests for Contribution 

That is all news for on the present time, thanks for studying!

Subscribe to @rust_gamedev on Twitter
or /r/rust_gamedev subreddit while you happen to desire to bring collectively new news!

Discussions of this post:

Read More

Leave A Reply

Your email address will not be published.