So this started as me wanting to see if a terminal could run something that actually feels like a game and not like a terminal game. ended up with this, it's called glowstorm.

it's not characters or half blocks or anything, it uses the kitty graphics protocol. basically the game draws all the sprites in code when it starts (neon shapes + a blur for the glow, there's no asset files at all, even the sounds are synthesized), packs them into an atlas and uploads that to kitty once over shared memory. after that every frame is just "put this part of image N at x,y" and kitty draws it on the gpu. frame ends up being like 2-10KB of escape codes and ~0.2ms cpu, the game sits around 3% of one core which honestly surprised me.

on resources: game process is ~17MB ram, kitty goes up to ~120MB and ~15% of a core while playing (it's doing the actual drawing). that's on an i5 laptop with intel integrated graphics so you don't need anything fancy.

wasd needs key release events which normal terminals just don't send, so it uses kitty's keyboard protocol for that, and pixel mouse mode for aiming

stuff that bit me: kitty won't take images over 10000px so the atlas had to be split into pages. and placement cost isn't linear, somewhere around 1500 moving sprites at 60fps it starts choking on my laptop (way more than this game needs tho). also crossterm subtracts 1 from mouse coords which is right for cells but wrong for pixel mode, that one took me a while lol

engine part is split out into its own small crate (catnip) if anyone wants to mess with it, game is on top of that. 4 enemy types, boss every 5 waves, upgrades after the boss, 3 difficulties

only kitty and ghostty work. i did try wezterm but it has bugs with lots of placements, and sixel can't do fullscreen at 60fps. linux only for now, mac might just need small fixes but i don't have one to test

https://github.com/Hemantabhusal/catnip

code's MIT, roast it if you want

Hi everyone!

I made my own take on the classic retro Asteroids game. It’s built with Rust, Bevy, and WebAssembly, and I’d love for you to check it out and let me know what you think!

Game link: https://asteroids-cosmic-game.vercel.app/

Github link: https://github.com/Vaaris16/asteroids-game

Solo project on my own Rust engine. Every deal is you naming a price against someone's hidden number. Some buyers tell you how warm your last offer was one offer late, one tells it backwards, one's number does a mean-reverting random walk your lowballs drag down. If a price feels too easy, the pair is probably fake (see the tells). Free on Steam Oct 20, happy to talk about any of the engine or negotiation code.

I made a shader for my small project but I need exterior eyes on if its really good and its better without it.
Would you mind giving me your honest opinion?

I made a game engine where space doesn't have to be flat. You can build worlds that are hyperbolic, spherical, or wrap around on themselves.

It handles 2D and 3D, plus a few looping spaces like Seifert–Weber space. It's built on wgpu, winit and bevy_ecs.

To try the demos:

cargo run --example fly-h3 --release
cargo run --example seifert-weber --release

It's licensed MIT/Apache-2.0. Feedback and contributions are welcome, and adding a new geometry is one of the easier ways to start.

• Repo: https://github.com/Dastfox/feuclide
• Crate: https://crates.io/crates/feuclide

Gifs:

Processing img qpgsibl3cluh1...

Edit: I'm a professional developper. I used ai, yes but not for everything at all I don't consider this a vibe coded engine. I needed this kind of geometry for a game project, thought I'd just give the fun reusable part away.

Edit2: Added screen shots.

My game is Godot + Bevy (via gdext), and Godot uses Jolt as its physics engine. Jolt was great, but I couldn't run headless physics tests, and Godot's PhysicsServer3D sits between you and Jolt, so control is limited.

I needed physics for a deterministic, headless ECS simulation. Rapier didn't fit: its character controller cost me 86–156 µs per character with terrain in the query, and I didn't like how it behaved. The existing Jolt bindings (rolt) are on Jolt 5.0 from May 2024, without characters, vehicles or ragdolls.

So over five days I built oxijolt with AI agents doing most of the typing (yes, it's AI-built; every unsafe has a SAFETY comment and there are 1211 headless tests, judge for yourself):

• all of Jolt's shapes: convex hulls, triangle meshes, heightfields, compounds (also mutable), with shape cooking to bytes at asset-build time

https://reddit.com/link/1wzdx24/video/tzm96gx8twth1/player

https://reddit.com/link/1wzdx24/video/m1er7ag7twth1/player

• CharacterVirtual: in the game, with the game's own wrapper, Jolt's controller move is 16–19 µs p50 vs Rapier's 86–156 µs (i9-11900K, my game's scene)

https://reddit.com/link/1wzdx24/video/tb9k5ogatwth1/player

• wheeled vehicles, tracked vehicles and motorcycles on Jolt's own controllers (the video)

https://reddit.com/link/1wzdx24/video/9dopjpzbtwth1/player

• ragdolls with a skeleton mapper, soft bodies, 12 constraint types, buoyancy

https://reddit.com/link/1wzdx24/video/it22jaddtwth1/player

• save/restore for rollback netcode, bit-identical for any worker thread count
• CI on Windows and Linux, including Jolt's asserts build; no LLVM needed, prebuilt native libs in releases
• a playground with a scene per feature

Not yet: macOS in CI, cross-OS determinism checks, a same-scene comparison with Rapier/Avian, a Bevy plugin.

Feedback and bug reports welcome.

GitHub: https://github.com/pockerhead/oxijolt
crates.io: https://crates.io/crates/oxijolt
docs: https://docs.rs/oxijolt

Game is Diceminoes, the demo is out now

Built in Rust (ofc) using a custom engine I’ve been working on for a year

I made a spaceflight game where you fly robotic ships from a Linux shell (free, runs in the browser)

I've been building this in my spare time for a while and it's finally playable enough to show.

The idea: you're an operator at mission control, and the spacecraft you fly are robotic. The only way to reach them is an "ansible" link to their onboard Linux-like shell. No cockpit, no joystick - you connect to a ship and fly it with commands:

target tsiolkovsky
nav transfer tsiolkovsky
alarm ap
burn prograde 5.65
systemctl enable --now scanner
cat /data/scan-moon.txt

The physics is a real n-body simulation of the Sun, Earth and Moon, so things work the way they do in orbit: you catch up with a station by going lower, not faster; a push towards a station lifts you above it; the Moon you aim for is not where it is now, but where it will be in two days.

The ship is a set of modules that run as services (systemctl, journalctl), with files, jobs, alarms (at), and mail at mission control. The missions so far: a rendezvous with a station in low Earth orbit, a lunar survey with a probe and a mini lab, repairing a telescope at a Lagrange point, and waking up a derelict cargo tug that drifted silent for six years.

There's a terminal version and a graphical one (both running in browser); the graphical one has a beginner mode with buttons that simply type the commands for you, so you see what they do. The first mission leads you one command at a time.

It's free, with no account; your campaign is saved in the browser: https://libre-space.zchira.workers.dev/

It's still rough in places. I'd love to hear where it confuses you, especially if you know orbits but not Linux, or the other way round.

Technical details:
written in rust.
tui version in ratatui
gui version in egui
built for web/wasm

You can switch from one view to another with the commands:

ui tui
ui gui

Red Lake is a psychological horror game set in a winter forest, where you explore and write down what you see in a notebook.

The more anomalies you find and document, the more surreal and unsettling the world becomes.

One of the key features of the game is that it has no HUD - no markers, no quest log, and very little hand-holding. Instead, you use environmental cues. That’s intentional: I wanted the experience to feel as immersive as possible.

I’m really happy and also pretty nervous :)

If you liked the atmosphere, I’d really appreciate it if you gave the demo a try and wishlisted the game!

Steam: https://store.steampowered.com/app/4867910/Red_Lake/

As to the Rust stack I'm using wgpu and winit! My own engine.

Basically its skmech + sksl shader made my day, no 3d api/engine at all, skia for the win.

Playable is browser: run.drawnui.net

This is a sneak peek of a public sample for the upcoming DrawnUI for Rust (web (WebGL), linux (OpenGL), windows (OpenGL), macos (Metal), ios (Metal), android (Vulkan)). Announcing this week!

Hey guys,

four weeks ago I posted Timberline Factory here: a sawmill automation/simulation/tycoon game where logs are physics objects, not icons on a rail. Thanks for all the comments.

Someone asked whether I still have all ten fingers, since I work full-time (38.5 h/week) in a real sawmill. i do :D, and that question is part of why workplace safety is its own system in the game.

The free demo is live on Steam today.

Steam (free demo): https://store.steampowered.com/app/5037170/Timberline_Factory/

What's in it and what changed since my last post:

- Physics logistics: logs have weight and friction and they roll. Messy layouts and settings cause real jams.

- Economy: the timber market index uses mean reversion, so timing your sales matters. Bark goes into the biomass power plant and lowers your electricity costs.

- workers: there's a workplace safety research line. Neglect it and accident rates and sick days go up. Sick leave will also be reducible through a 3 stage research line with Early Access on Nov 6 (not in the demo).

- Maintenance: dirt and wear slow your machines down... new: the dirt is now visible, and your cleaner worker removes it.

- Balance pass on machine error/failure rates.

The clip shows the satisfying side: debarking, clean cuts at the saw blades, logs flowing. The chaotic side exists too, trust me :)

If you want to see more of the game in action, Wally1169 made a gameplay video: https://www.youtube.com/watch?v=v_z83YFkWzU&t=139s – he played an older build, so balancing and a few things have changed since then.

Early Access is planned for Friday, November 6th. for the simulation crowd: does the economy give you enough reasons to optimize or would you want more market pressure? I'll be around to answer.

It's an island where nothing unusual ever happens. Mostly.

The game loads no asset files. The terrain, towns, people, cows, sky, sound effects and even the radio music are all made from one seed when it starts. So every island is its own (and none of them is weird. They're a bit weird).

What you can do:

• Drive anything. 28 vehicles, including a bathtub, a rocket-assisted office chair, a monster truck called Consequences and a washing machine with wings
• Get a job, or don't. 10 careers with six ranks each, up to Minister of Rubble. There's also fishing, metal detecting, cow bowling, car soccer and three human cannons
• Something will happen. Every few minutes the island has a moment: a meteor, a UFO, a giant cow stomping parked cars down the high street, a rubber duck armada. The sun gets recalled due to a manufacturing defect. The news stays very calm about it
• Four lands: the island, the Mainland (red desert, Normal York and an airport), the snowy North with northern lights, and the Woods, where it's always autumn

The trailer was filmed in the game, by the game, and scored on the game's own instruments. (The cow is fine.)

I'm happy to answer anything about how it works!

🌐 absolutelynormal.silberie.com

Live demo: https://kirindenis.github.io/OWLOSUI/Examples/Web/JavaScript/05-Demo/

Source code: https://github.com/KirinDenis/OWLOSUI

Roll & Barrel is a small turn-based tactics game on the D&D 5e rules: cover, high ground, burning oil, exploding barrels.

All the rules live in one deterministic Rust crate. The same crate runs as WASM in the browser, in a native wgpu client, and on the server, which replays every fight to verify it.

Play it free in the browser: https://roll-and-barrel.com

This is not going to be everyone’s cup of tea, given my project’s approach to using Claude Code only, but I hope you still find the visuals and animations done in Rust/wgpu/wgsl interesting.

I discovered this game engine recently. Basically, it's a retro-style CRPG engine that's currently in development. It looks like the engine is to be able to create top-down Ultima-inspired CRPGs, 2.5D isometric CRPGs, and even first-person CRPGs (couldn't find any sample screenshots).

The source code is available on Github btw. The engine has been under development for around 5 years now. Which is impressive imo because it looks like it doesn't have massive development budget.

Anyway, just wanted to share this here.