Bevy News

TL;DR: I started making a video game. I assumed 2D video game art generation was a solved problem. It wasn't. I tried to solve it and ended up getting close. This post's URL provides an example of how far image generation models have come (and how far coding LLMs have come, because they built that entire website, with my assistance, in 2 months). Long Post: I originally started programming because, like many others, I wanted to make video games. A bachelor's degree in Computer Science, a few internships in Silicon Valley, and some year-long stints at various companies that shall not be named here -later, I ended up where I started from: making video games. I set out on my game-making journey intent to fully embrace change, because the times they are a-changing, as they always seem to do. First, I'd write the game in Rust, a language which I wish we had when I was in college (though I admit learning C is absolutely a pedagogical rite in any up-to-snuff CS program). Second, I'd use LLMs to guide me on my way. I quickly found my bearings with the Bevy game engine [1]. I implemented Flappy Bird for practice. Sailing was smooth. It was time to make the game I originally intended to make. Early in the development of the game I found the need to procure assets. I had already stumbled upon Meshy [2], a web app that let's you create 3d meshes from prompts. I think this is a great product and I gladly paid for it. However, I was making a 2D game, and 2D games need 2D assets. I…

There's also ongoing work on the (for now hidden) Bevy Book https://bevy.org/learn/book/intro/ Already seems like a great resource to me but it's still WIP.

I've been evaluating texture compression options for including in Bevy https://bevy.org, and there's just, not really any good options? Requirements: * Generate mipmaps * Convert to BC and ASTC * Convert to ktx2 with zstd super-compression * Handle color, normal maps, alpha masks, HDR textures, etc * Open source * (Nice to have) runs on the GPU to be fast I unfortunately haven't found any option that cover all of these points. Some tools only write DDS, or don't handle ASTC, or want to use basis universal, or don't generate mipmaps, etc.

> The current roadmap lists Shadow DOM and CSS Grid as priorities I've been working on the CSS Grid support. About to land "named grid lines and areas" support which should make a bunch more websites layout correctly. I'm biased because it's my project, but IMO the approach Servo is using for CSS Grid is pretty cool in that the actual implementation is in an external library (Taffy [0]) that can be used standalone and is widely used accross the Rust UI ecosystem, including in the Blitz [1] web engine (which also uses Taffy for Flexbox and Block layout), the Zed [2] text editor, and the Bevy [3] game engine. I'm hopeful that this approach of breaking down a web engine into independently usable modules with public APIs (which builds upon Servo's earlier work on modular libraries such as Stylo and html5ever) will make it easier for people to get involved in web engine development (as they can understand each piece in isolation), and make it easier for people to create new web engines in future (as they won't have to start completely from scratch). [0]: https://github.com/DioxusLabs/taffy [1]: https://github.com/DioxusLabs/blitz [2]: https://zed.dev [3]: https://bevy.org/

Also see the stability warning for Bevy at https://bevy.org/learn/quick-start/introduction/ and decide if you're ok with that for your game.

Really depends: In some areas it is quite advanced (rendering) and in others it is lacking / underdeveloped (editors / tooling). But there is an incredible amount of progress and also churn in keeping up with that. https://thisweekinbevy.com/ https://bevy.org/news/

> I believe Chromium development often uses a mode with .dlls dynamic linking instead of what they release which is all static linked exactly to speed up incremental development. The "fast" case is C not C++. Bevy, a Rust ECS framework for building games (among other things), has a similar solution by offering a build/rust "feature" that enables dynamic linking (called "dynamic_linking"). https://bevy.org/learn/quick-start/getting-started/setup/#dynamic-link…

Good learning resources for those curious: - https://taintedcoders.com/ (I'm the author) - https://bevy.org/learn/book/intro/ - https://www.youtube.com/@chrisbiscardi - https://www.youtube.com/@PhaestusFox Lots of good stuff on the official Bevy discord too

Come on. There's no “big tutorial” though. There's a section about compilation time performance[1] but it's arguably not “big”, and the most impactful parts of it is about linking time, not compilation time. And half of the section is now obsolete since rust uses `lld` by default. [1] https://bevy.org/learn/quick-start/getting-started/setup/#enable-fast-…

Addition to other comments, (most of) Bevy's examples are both available in WebGL and WebGPU so useful for comparison. https://bevy.org/examples-webgpu/ + https://bevy.org/examples (WebGL)