Liblast

https://mastodon.gamedev.place/@liblast

Liblast is an open-source multiplayer FPS game built with Godot 4 game engine and a fully open-source toolchain.

Visit: https://libla.st
Contribute: https://codeberg.org/Liblast/Liblast
Watch: https://www.youtube.com/@liblast
Donate: https://opencollective.com/liblast

Public Key

npub1jxatazuxqvmp477r0gf3pwpqj386g0pqq2qradxzztzg5afcpnjq7jxr5u

NIP-05 Address

[email protected]

Profile Code

nprofile1qqsfrw473wrqxds6l0ph5ycshqsfgnay8ssq9qp7knpp93y2w5uqeeqpz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dszdhhw3

Publishing to

relay.damus.io

nos.lol

Author Public Key

npub1jxatazuxqvmp477r0gf3pwpqj386g0pqq2qradxzztzg5afcpnjq7jxr5u

Show more details

Last Notes

2026-03-19 19:04:53 GMT

For a long time I wanted to try and make some blinking lights.
"What's so special about that?" I hear you say. Well, you see - real server racks or nuclear power plant control consoles don't blink completely randomly. There's intricate relationships between individual lights, rows of lights, entire racks... and the time factor.
I have created a texture storing 256 different patters. Special UV layout + vertex colors + of course a special shader and we can have this:
#techArt #Godot #server
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/257/365/694/847/422/original/cfa47cb59c0354e7.mp4
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/257/384/691/695/041/original/09421c3c2cce579f.png

2026-03-19 13:18:48 GMT

Stretching our 3D asset pipeline by fleshing out the test level Drill with custom props. No unique textures added for these models.
- unfa
#Godot #Art #3D #Liblast
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/256/012/302/361/282/original/fc3d7c212f6a69ad.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/256/028/955/686/026/original/f1c86ba1e49ca557.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/256/032/018/893/174/original/d40c705788d32317.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/256/033/381/917/320/original/e537a5f21b8478a1.png

2026-03-17 12:51:34 GMT

- reply

Relevant files are game.gd, entity.gd entity_component.gd, actor.gd, actor_controller.gd, game_state.gd (I am unsure of its role yet - holding ethereal state of game that is not entities? Maybe all that should be implemented as runtime CVars instead?)

2026-03-17 12:29:53 GMT

- reply

Sure! I am working in the devel-unfa branch, you'll see breakage there trying to run the game. There's a map called actor_test that is used as a prototypibg ground for redesigning this whole entity system.

2026-03-16 13:45:58 GMT

- reply

By `subtick`I mean situations where player1 shoots and kills player2 in the exact same tick when player2 shoots and kills player1. In theory with hitscan weapons, one should die, not both. Reordering events by mouse input time could allow resolving such cases with certainty, rather than randomly or arbitrarly by whoever joined game first gets their shots processed first (like in TF2).
I also hope this could allow rollback in the future and lag compensation, but i should NOT worry about it now.

2026-03-16 13:43:19 GMT

- reply

Having events neatly in a queue also means Game could reorder them, group them by type for processing on multiple worker threads etc. For example InternalEvents could be all processed in parallel, because they don't touch anybody else. Then ContactEvents involving pairs of entities (rocket -> character, hammer -> box, explosion -> barrel) could be separated etc etc...
Huh. This could be very powerful and also allow good debug.
It could also allow sorting events by server_time_msec for `subtick`.

2026-03-16 13:36:28 GMT

- reply

Right now Entities can affect their state directly, and by extension - world state, which means that depending on semi-random order of node script processing, results can vary.
Ok, I need to address this.
Generating events can be parallelized later, processing them - I am not sure, because here events alter the world_state. However events could be divided into clusters by groups of entities they involve. An explosion in room A will affect entities 0..4 but will not touch entities 5..20 etc.

2026-03-16 12:37:56 GMT

If anyone is interested in #FPS #multiplayer game technology and happens to know #Godot, I am open to talk :) Hi me up here or join our chat athttps://liblast.zulipchat.com
I am currently wrestling with an entity and world state system. I have a problem because I would want to be able to do `if node is Entity: stuff()`, but root nodes of various scenes (like a game character, and interactive prop etc) uses a node type like CharacterBody3D which properties I want to access, but also extend Entity

2026-03-15 14:24:00 GMT

It's never pleasant to realize some of your work needs to go, but I've come to the place where I think my entity system is way too complicated, and instead of making things easier, it's now making things harder. I'm trying to do too much, too quickly. I'm trying to implement very advanced multiplayer features before I have basics working well. I don't think I'm ready, I need to go back to the simplest possible solution that will be working, and expand from there.
Back to the drawing board!
-unfa

2026-02-26 13:28:27 GMT

Thanks to our powerful 3D asset pipeline and ubershader a simple model can provide a lot of visual variety. Edge bevels and wear, worn paint revealing raw metal underneath - these effects come easily and with little artist effort. Altering asset colors per instance is also possible. Reusing textures heavily for common effects removes the need to add bevels, wear & tear to your props. Model them pristine and let the framework do the rest!
Wanna learn more?
Follow #LibreGraphicsMeeting !
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/137/142/182/214/494/original/3bf3299370f7e706.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/137/146/074/029/560/original/22baf008e3f947d2.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/137/148/636/142/772/original/50e58da114b307e6.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/137/151/512/427/694/original/e682d4656233cbea.png

2026-02-24 22:01:36 GMT

Booking my flight and room for #LibreGraphicsMeeting to show Liblast to the world!
I'm going to do a presentation and a workshop during which me and the audience will make some 3D assets using our sick pipeline. The event will be streamed live, so either GetOverHere or GetInTheChair!
https://libregraphicsmeeting.org/2026/program/
- unfa
#Liblast #LiblastFramework #Godot #GodotEngine #Blender #Blender3D
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/127/845/440/842/915/original/91e8e7f69a5724f0.png

2026-02-23 18:36:37 GMT

New Liblast builds and dev update are available in our Zulip server:
https://liblast.zulipchat.com/#narrow/channel/462542-general/topic/playtesting/near/575361787
Also new development update video showcasing the game state from these builds:
https://video.hardlimit.com/w/sc6yu4D5izGZu9JTB3xAUf
Enjoy!
- unfa
#Liblast #Godot4 #FPS #IndieGame #Shooter #SciFi #Robots #unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/121/306/584/896/816/original/b089faa456c063c8.png

2026-02-23 18:26:42 GMT

Recent update video now on PeerTube! Thanks to HARDLimit for allowing us to host video on their platform!
https://video.hardlimit.com/w/hMpc7v96TJ9eGYRHDd2JJP

2026-02-22 23:46:07 GMT

"Misaligned lightmap type beat feat NaNs"
#glitch #accidentalart
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/116/941/408/087/970/original/acec2a3bb132a1c1.png

2026-02-22 14:52:00 GMT

Improved crosshair. The circle size is set in degrees and depends on camera FOV and viewport size.
This means if the weapon spread is later tied to the circle size, it will reliably show area of spread, no matter what camera FOV and resolution the game is running at.
#Godot4 #Liblast #FPS #IndieGame #OpenSource
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/114/832/349/104/657/original/0999b8791a3b39ec.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/114/833/761/540/999/original/c8d7bb54ed74a34a.png

2026-02-21 20:29:35 GMT

Stuff I'm currently working on.
https://youtu.be/EWNi2wnkpAs
- unfa

2026-02-17 22:36:46 GMT

Liblast on the agenda for #LibreGraphicsMeeting ! I'll see you in April in Nuremberg!
https://libregraphicsmeeting.org/2026/program/
- unfa

2026-02-17 16:28:06 GMT

Improving performance and visual quality...
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/086/910/477/027/291/original/8c0695bd0a84df83.png

2026-02-16 18:03:38 GMT

Expanding the test level. The performance now is really bad (20-ish FPS), the lighmap fidelity is also really bad, but this is how we find the pain points. A larger level is definitely needed to see how the game behaves.
What is definitely needed is splitting the map into multiple rooms and using occlusion culling to get rid of geometry that won't contribute to the frame. So far the whole level is just one humongous mesh.
We need a non-destructive way to split the mesh with no new faces.
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/081/587/052/990/057/original/99f5f5137c95714d.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/081/587/134/380/213/original/08c0790584e39ac8.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/081/587/132/713/604/original/10f281d19811c64b.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/081/612/978/965/007/original/15845068fdc4f001.png

2026-02-13 11:55:19 GMT

Spawnpoint in-editor gizmos now feature a POV preview sprite. You can align the spawnpoint and see what the player spawned at it would see :)
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/063/185/750/962/367/original/419e6c946d6609bc.png

2026-02-13 01:12:08 GMT

Liblast running on Fairphone 6 at 80 FPS. #fairphone #GodotEngine #TheFairphoneGen6 #Fairphone6
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/060/643/748/229/885/original/40943f8ea0b93169.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/060/657/523/633/828/original/538f3f696a889d59.png

2026-02-12 14:32:20 GMT

Experimenting with a level design workflow in Liblast Framework.
Blender required some weird workarounds to get CSG-style subtractive modelling working, but I got it figured out.
I had to create a gigantic cube from which I subtract the world. That cube has a vertexgroup "omit" set and a GeometryNode modifier deletes that geometry dynamically AFTER boolean operations.
For modelling this is now transparent, you don't even see that cube, and it doesn't affect lightmaps.
This can be a template.
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/058/097/077/051/716/original/117bc47ec4a477de.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/058/126/775/144/385/original/61d81cf5591c5fd8.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/058/140/224/700/329/original/81164796f11c6339.png

2026-02-09 13:09:01 GMT

Running the game on super underpowered systems is always so satisfying!
Here's Liblast on ASUS T1000AH tablet running test level at 50 FPS. It crashed soon after, but it did run smoothly for a moment :D Arch Linux and Cage. can't find a way to make this screen landscape though.
#indiegame #tinkering #Linux #Liblast
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/116/040/819/840/630/540/original/03f26eb57c1ba925.jpg

2026-02-01 20:15:49 GMT

What if we just use the world model as view model and attach our camera to the model's head?
- unfa
#liblast #Godot #Godot4
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/997/202/813/674/578/original/8d24e2c4d1c3af36.mp4
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/997/197/927/098/414/original/e35c10b8dbb7497e.png

2026-01-31 17:05:41 GMT

Wait... something isn't quite right...
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/990/795/661/355/054/original/fbeaef03f74493f5.png

2026-01-30 23:08:19 GMT

Replacing the placeholder gun with an "assault rifle" model I have made some time ago. Not sure if it'll fit the artstyle, maybe we;ll loose the scope - why would robots need scopes? :D Scale is all wrong, and putting Robot's hands on the gun is gonna take some work...
- unfa
#3d #Godot #Blender #fps
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/986/556/436/359/195/original/aa2af01dfdef72fd.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/986/557/394/140/614/original/a494d0aa7e027cf5.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/986/557/523/911/133/original/1e8df8e1157ba5f4.png

2026-01-28 17:53:54 GMT

Liblast running on Android (#FairPhone6, #FairPhoneGen6, #TheFairphoneGen6), #Godot 4.6 stable.
#Liblast
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/973/997/860/012/645/original/2d1ed4c7177f3073.png

2026-01-24 11:40:54 GMT

Working on Entities and Components. Things are starting to come together on that front. Also improved character physics. Characters now really feel like they have some inertia (not too much).
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/949/876/498/804/509/original/205e212e607f5146.png

2026-01-22 18:58:55 GMT

- reply

thanks! This is an open source project, so if you'd like to work with me to improve things, I'm always there! :)
- unfa

2026-01-22 17:08:38 GMT

Playing with the Raspberry Pi 4. Can it run Liblast?
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/939/848/704/453/245/original/e4326bc8059575c9.jpg

2026-01-22 16:11:37 GMT

- reply

TL;DL: The interface should remain object oriented because working with a bunch of tables is not as user friendly as working with a bunch of objects laid out in 3D space. However, in the future, everything could be baked into an ECS, maybe even ditching nodes entirely and working directly with Godot's servers. That is, unfortunately, a bit too ambitious for me, and I think it should be more of Liblast Framework 2.0, and 1.0 should be fully object-oriented just for the sake of simplicy.
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/939/617/793/578/884/original/4d458f7102ac21c6.mp3

2026-01-22 12:56:55 GMT

Sketching ideas in Excalidraw.com.
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/938/857/275/010/497/original/9db0e15314bbe5d4.png

2026-01-22 12:49:56 GMT

When thinking about entity, component, state and networking systems I realized I am starting to lean into functional instead of object-oriented. The problem is, I think it's too early. I should first do the simplest possible working implementation of the design, and once that's solid, seek ways to improve it if need be. Of course from performance standpoint it'd be best to do everything in C++ and go full ECS, but the flexibility and ease of development are among paramount values here.
- unfa

2026-01-14 15:27:11 GMT

3rd person camera. This makes debugging so much easier!
- unfa
#liblast #Godot #GodotEngine #game #indiegame #devlog #gamedev
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/894/149/377/592/536/original/00afbe365ccd4b59.png

2026-01-14 15:26:15 GMT

Quake-style speedometer added that calculates lateral speed relative to current floor plane.
Also 3rd person view.
Also splashscreen for Liblast (a bit pre-emptive).
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/894/142/250/872/267/original/1f9fba8abb900ef1.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/894/142/453/794/846/original/e36992ca0b5fc5c5.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/894/142/662/867/228/original/8b8c6d12480560db.png

2026-01-13 16:20:57 GMT

Implemented basic sound occlusion into the new AmbientSound entity class. Also Made a custom icon for the entity. I suppose using the gradient from Liblast Framework's logo makes it distinct and easy to understand what it is. Or does it?
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/888/427/131/988/763/original/5ab6418b6a8400e7.png

2026-01-06 22:55:45 GMT

We're starting to look legit, aren't we? :)
#Liblast #LiblastFramework #Godot #GodotEngine
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/850/613/645/517/330/original/01bdfc2fba95a31a.png

2026-01-05 00:25:47 GMT

More eye candy from the game menu :D
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/839/646/249/549/717/original/c064734cab70e50c.png

2026-01-05 00:07:19 GMT

I am designing a logo for Liblast Framework. The Framework is the technology stack built for Liblast (the game). Having separate visual identies would help show what is what. Liblast Framework is going to be Godot Asset you can install and have all the advanced, integrated tools and a powerful 3D asset pipeline ready to go for your game. Liblast (the game) will be built on the Framework and server as a primary showcase and breeding ground for it's features.
- unfa
#Inkscape
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/839/558/476/156/237/original/0c9944061e1e491e.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/839/571/139/180/294/original/d6c2c4354dfa1e87.png

2026-01-04 20:40:18 GMT

If you need some #glitch images I have found an interesting way of generating that with #GodotEngine 4.5.
If you create a SubViewport and change it's size at runtime, odd things happen - it seems that the frame buffer is not initialized which displays mingled data (sometimes it's parts of what you see onscreen, sometimes parts of frames from other viewports, like the main one).
@npub1af5…c5r2 don't patch this please!
Note: this is NOT reliable! That's why I saved the frames!
- unfa #art #pixel
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/838/730/897/201/325/original/2fd9b83d341750ba.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/838/735/075/239/983/original/66d142eb6fcf1863.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/838/735/087/717/641/original/d29e37ac8f8b95f3.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/838/735/073/889/921/original/542bc020710e1d61.png

2026-01-03 02:46:31 GMT

It just so happens that the new Liblast menu background scene is great for testing the completely new implementation of #SSR that is present in Godot 4.6 (beta2).
It's best appreciated in motion, so here's a video clip!
This runs at 144 FPS at ~2K resolution on my Radeon RX 6800 XT. 4x MSAA + TAA.
In a busy fast-paced game this detail won't matter as much, but seeing that Godot can deliver this kind of a picture, really warms my heart. You madmen did it! 🎆
- unfa
#Godot #GodotEngine
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/828/827/393/122/805/original/2b065086ac314d03.mp4
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/828/847/029/553/496/original/93e2fdf50cccc9ba.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/828/873/942/776/767/original/265de2609e158e23.png

2026-01-02 16:15:56 GMT

- reply

if I had the resources, I would be glad to maintain a Matrix space, find a way to bridge it to a Zulip channel and expose in-game. Perhaps a contributor would emerge in the future who would take care of that. There's already multiple places. There is Zulip, there is our Open Source Collective page and there is Mastodon. I wish I could find a way to uniformly publish updates to all of that + our website some time, but it's not top priority at the moment :)
- unfa

2026-01-02 13:41:27 GMT

- reply

no, Matrix is just not the tool for the job. Zulip is designed specifically for productive team collaboration and has a multitude of unique features.
Examples in no particular order:
- Transparent interface via email
- Custom code playgrounds
- Timezone-aware timestamps (great for scheding meetings)
- Multitude of channels and channel groups in one instance
- Webhooks - pulling info from Git hosts
- Custom url shorteners (git issues)
- GDScript colors!
- Fast search
- unfa

2026-01-02 01:10:03 GMT

Slowy bringing out the colors!
#Godot #GodotEngine #Liblast #LiblastFramework
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/822/815/322/675/718/original/d50d07a024ba49db.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/822/816/565/269/829/original/2ca29c00ececb041.png

2026-01-01 22:06:20 GMT

Making progress! Stuff is slowly coming together. Too much to mention everything here.
More information can be found on our Zulip chat:
https://liblast.zulipchat.com/#narrow/channel/462542-general/topic/playtesting/near/565999261
Maybe I'll manage to make a video and demo all the new stuff (once the cold finally passes - my new year's was spent lying in bed with a laptop).
I managed to bang out some decent code though. Maps now automatically render and save previews. These are shown in game builds during loading.
New cvar: debug.override.spawnpoint
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/822/095/624/217/281/original/3c1c0b44af79295e.png

2025-12-17 16:46:40 GMT

#Photo #notAI #notCGI #realPhoto #Godot #GodotEngine #GodotPlushie #Liblast #unfa #3Dprinted
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/735/913/352/852/959/original/226285d1af2b476a.jpg

2025-12-17 13:58:31 GMT

Progress in the (tech) art departament.
Rendered with 4xMSAA, nothing else.
I found that Screen-Space Roughness limiter works in halved resolution and introduces blocky artifacts (check the 2nd screenshot for comparison).
It's probably content-specific but the effect is ON by default, and so you might be getting stairsteppy artifacts and not know where do they come from.
This is Godot 4.5.1 stable on Arch Linux. Haven't tested in 4.6 beta yet.
@npub1af5…c5r2 WDYT?
- unfa
#Godot #GodotEngine
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/735/236/152/813/113/original/3e5f02077abeffcd.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/735/242/117/751/606/original/15feae6e7032cc26.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/735/254/694/564/378/original/ea23ea9e74883826.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/735/255/587/897/898/original/809a7e806a872fa4.png

2025-12-15 18:23:59 GMT

Ubershader overhaul imminent! In my professional work I have used some ideas and even tooling (vertex color baker for Blender) created for Liblast. I have managed to implement quite a slick ubershader that handles car paint, localized damage to it, paint chipping and scratching, dirt, dust, rust, wetness, water and soap overlays among other effects like hilighting dirt, a dissolve effect, wind waves on cloth etc.
I suppose I could design something similarly modular for Liblast?
- unfa

2025-12-12 23:22:44 GMT

- reply

And here a still from one of the animation frames.
I am using the animation to ensure the textures are not "floating", and the material is behaving correctly.
The normal map seems wonky, something is not right, could be green channel needing to be flipped, or sRGB color space, we'll see...
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/709/159/237/211/277/original/0f8628f0cf0521d4.png

2025-12-12 23:18:30 GMT

- reply

Testing the model in #Godot using our ubershader.
Things are far from perfect, but we're getting there...
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/709/146/286/442/407/original/31ceab848b05d9b6.mp4

2025-12-12 15:46:40 GMT

- reply

And here's the atlas in action... after some modifications to it.
The texturing is not yet complete, but I'm getting close.
#Blender
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/707/370/420/973/400/original/f36970e746ea3d3b.png

2025-12-10 13:53:13 GMT

Hardsurface detailing atlas for #Liblast. Made with #Blender and #GrabDoc add-on and post-processed with #MaterialMaker. This is to work with a special #ubershader to let low / mid-poly models look almost hero-like :)
On the left a pre-vis of the final texture on geometry prepared for #DreamUV , on the right source geometry used to bake intermediate maps.
The final texture is in CXOY channel-packing layout. One texture merging curvature, normal and AO parameters.
#TechArt #Godot
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/695/566/416/373/653/original/3d98d7a4ffa5c42c.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/695/595/908/858/832/original/83fd1af3c6da2eba.png

2025-08-14 15:59:41 GMT

Sometimes we just wanna make a fun thing, even if it's not necessary by any means...
Like randomized serial numbers on weapons. Together with randomized wear patterns on them - gives a nice organic feel to it. Every single gun is unique!
That's stuff you can do very easily in Liblast Framework using our Ubershader.
The serial number is not a decal or a Label3D, it's part of the material.
The models are of course totally placeholder (just Godot primitives).
- unfa
#Liblast #IndieDev #Godot
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/115/027/911/023/154/914/original/9fd9be57535c3ef5.png

2025-08-14 15:49:38 GMT

- reply

I think if the straight segment slope would match the sine wave it was spliced to, the speed (1st derivative) should be fine, I would expect a hitch on the 2nd derivative (acceleration).

2025-08-10 11:28:48 GMT

- reply

Video now available on PeerTube:
https://video.hardlimit.com/w/bZsQCLyZTQiqwuuJaWrSUG

2025-08-09 12:13:47 GMT

The new Entity, World State and Replication system is working!
Here it's syncing 24 cubes and two movers (the chars are not based on entities yet) from a server to 3 clients.
The server's world state is authoritative - clients merely follow updates they get.
Super simple for now - full world state is sent to all clients every server tick.
Not optimal or resilient at all - there is a lot of work ahead!
https://youtu.be/Sc42ebGX_YU
#Liblast #IndieDev #IndieGame #Godot #GodotEngine #FPS
- unfa

2025-07-27 14:08:59 GMT

Heck yeah! The SharedTime feature of #Liblast #Framework that establishes a common time reference so clients can time events in server's time seems to finally work as expected. This took a lot of debugging, but it's here!
Of course this is only via loopback on a single machine, so only using this over the internet will tell if my code is any good...
So far I'm happy with the results :D
This is not yet in the main branch of the git repo, there's more coming ;)
- unfa
https://codeberg.org/Liblast/liblast-framework/commit/b3ddfbbc774c52af026cbb52b51ff2d86d83462d
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/925/583/205/447/390/original/4df2d10f4e27df94.mp4

2025-07-15 22:57:03 GMT

- reply

They said it's better to make more commits, because when you break stuff, you have more options during a bisect.
Well, so I have now committed about ~3 evening's work in 9 commits.
Note to self: don't be afraid to commit, because you're not sure if you'll go down this route or not. #Git history is exactly the tool to go back to a place before you went off-rails.
I often hold back because I feel like maybe this should go to a different branch, maybe not...
Maybe I'll first merge up...
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/859/696/290/357/046/original/cd12d06a58475432.png

2025-07-15 22:16:25 GMT

Inching forward. For now just trying to get this to work in the simplest way possible. Basic FPS game networking - character movement first.
- unfa
#Networking #Godot #IndieDev #Liblast
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/859/539/785/331/102/original/750a9ee111761b43.mp4

2025-07-13 22:22:42 GMT

New development update video!
https://youtu.be/pvjU2Sc9Tms
I'm working on networking.
Big brain energy needed. I've read and studied a lot about networking in FPS games throughout the years, but my own implementations so far have been rather unimpressive.
You think I can knock it out of he park this time around? I've been doing Liblast for 5 years now, this is the 4th from-the-ground-up iteration of the project. I hop I've learned my lesson by now...
- unfa
#Liblast #GameDev #IndieDev #IndieGame
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/848/255/061/787/930/original/9f139c78c4e7aaf1.png

2025-07-11 10:00:16 GMT

Liblast starting a local server and loading a map. You can notice recent work on loading screen and scene transitions. An important part of the map "loading" is rendering frames and comparing them monitoring the differences. The game is waiting until the frames stabilize. It took a lot of work to get working properly, but now it pretty much eliminates all possible flickering due to reflection probe baking (and other pop-in). Internally it's called "Flicker Suppression".
- unfa
#Liblast
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/833/991/809/838/170/original/9320750545ec5e39.mp4

2025-07-06 13:36:35 GMT

Long time no see!
Here's an update on Liblast [Framework] development, and further development taking place on video :)
https://youtu.be/4SvDGc2-gtU
- unfa
#liblast #godot #godotengine #indiegame

2025-06-24 11:18:34 GMT

- reply

It didn't die - it was killed. Thor aka Pirate Games has been spreading lies about what SKG was and trying to convince people it's a terrible idea - he has single-handedly doomed the movement. because he's a pr*ck. Then he fell off when people started realizing he's full of himself, but the damage was already done.
This could still be turned around, there's less than 600000 signatures required (out of a million), but there's a month+ left, and without a few huge YouTubers helping...

2025-06-24 09:00:45 GMT

WE HAVE ALMOST SAVED GAMING.
Or have we? Can we still save it?
All it would have taken was a million signatures from EU citizens.
Don't we have a million gamers in the EU who are eligible to vote?
Here's probably the last update from #StopKillingGames :
https://www.youtube.com/watch?v=HIfRLujXtUo
https://StopKillingGames.com
Have you signed yet?
-unfa
#Gaming #Game #Games #Gamers #LinuxGaming #GamePreservation #GameEmulators #Lutris #Proton #Wine #Steam #Freedom #EU #Law #GameDev #GameDevelopment #Help #Activism

2025-06-15 21:53:35 GMT

Working on various things.
#Liblast
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/689/593/472/043/748/original/8fae611aa9d6b145.png

2025-05-10 12:26:11 GMT

Ever since Godot 4.0 pre-alpha the reflection probes are sometimes causing flashes when baking their internal cubemaps.
Years later this is still a problem I don;'t know how to solve.
Maybe somebody has found a way to tackle this?
https://forum.godotengine.org/t/how-to-avoid-reflection-probes-from-flashing-white/110498
- unfa
#Godot #GameDev
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/483/525/344/302/226/original/d0d0418b9865d24e.mp4

2025-05-10 11:32:24 GMT

- reply

Yeah, it's a dev console in front of a test map for working on the character controlller (and also testing lighting).
- unfa

2025-05-07 22:17:18 GMT

I'm just gonna share what I'm working on at the moment.
- unfa
#Liblast #Godot #IndieDev
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/468/860/507/703/905/original/21004ba39794a0f7.png

2025-05-01 17:39:11 GMT

- reply

Hi! This was a result of our mitigation against a recent spam attack. It should be accessible as usual by now.
- unfa

2025-04-21 20:47:40 GMT

We've taken part in Godot Wild Jam #80 ( #GWJ80 ).
Here's the game we made:
https://liblast.itch.io/triangle-factory
https://codeberg.org/Liblast/godot-wild-jam-80
This short detour from our work on Liblast Framework has been great fun, and we have learned a lot about making games and working together.
- Liblast Team

2025-03-30 13:56:28 GMT

Don't think that lack of updates here means lack of progress on Liblast!
At thew start of the year, we've formed a new Team, and since we've been doing weekly work and team meetings. Nearly all of it happens in Liblast Framework repository, so you might haven't noticed:
https://codeberg.org/Liblast/liblast-framework
We're building the framework as a foundation for the game, and for future games too.
If you'd want to be a fly on the wall, or talk to us, join our online community on Zulip:
https://liblast.zulipchat.com/
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/251/674/385/778/209/original/5d8a9286b94cfff1.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/251/697/130/891/001/original/f2b6287f08ea4b76.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/114/251/701/226/566/928/original/6d3641c76fc32929.png

2025-01-13 23:06:12 GMT

This is THE year!
Here's a summary of what has happened in 2024 and what we're looking at in 2025:
https://opencollective.com/liblast/updates/2025-starts-with-a-rebirth-of-the-liblast-team
Enjoy a rare blog post by your's truly.
- unfa
#liblast #gamedev #Indiegame #Godot

2025-01-03 12:41:43 GMT

- reply

Zulip is quite different in approach to the whole concept. It'd say it''s a blend between chat, e-mail and an issue tracker. it focuses on responsiveness and keeping conversations untangled.
By default in Zulip a new message starts a "topic". This is different from most chat systems where messages sent to a channel are intertwined. It also has features like GDScript code completion, code playgrounds, TZ-independent timestamps, a lot of integrations to other services...

2025-01-02 12:59:47 GMT

Hey! I am moving #Liblast community towards new chat platform:
liblast.zulipchat.com
So all Liblastians - join in!
➡️ https://liblast.zulipchat.com/ ⬅️
I don't want to push people towards Discord or other proprietary platforms with dubious ToS's. Also Rocket.Chat (that we used previously) has become a burden and the company has been paywalling features for self-hosted users like us.
Contrast that with #Zulip that has sponsored us with premium free hosting, because we're a FOSS project :)
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/758/880/269/362/938/original/45cec47132c46f2d.png

2025-01-01 23:29:23 GMT

💥 2025 is surely going to be The Year of Liblast Desktop! 🎆
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/755/688/280/941/190/original/8af6b7d0a79f304e.png

2024-12-22 11:31:17 GMT

#Godot Engine 4.4 integrates GodotJolt extension into the engine as a core module. What's more - replacing Godot's physics core with Jolt Physics is on a priority list for the Godot team.
I am so glad that this is happening, because doing precise physics in Godot is a festival of odd hacks and wasting CPU cycles on triple checking faulty data that Godot physics core produces.
I want to shout out @npub1qf3…zpla who's been working hard to bring Godot's 3D physics limitations to light.
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/696/125/322/386/077/original/cf3bfb62ae5e2368.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/696/234/103/253/539/original/4232a4e959e204d7.png

2024-12-02 08:43:04 GMT

- reply

No, the character controller is made so that walking in any direction gives it the exact same speed of movement. You could modify the character controller if you want and add extra CVars to control the strafing boost though.
Albeit we haven't ported it the character controller to the framework yet so there's work to be done before that's going to be possible to do.
- unfa

2024-12-01 15:52:52 GMT

New git repository for the Liblast project!
Liblast-Assets
https://codeberg.org/Liblast/liblast-assets
This repository will hold source files for textures, 3D models, sound effects, music and any other media that might be created for the game and framework.
Historically we held this data alongside Godot projects and code, which proven to make things a bit difficult for contributors.
There's obvious and less-obvious trade-offs here.
Hopefully the tradeoff we chose this time will work out better for everyone.
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/578/345/471/492/396/original/587fbb9eaa29169d.png

2024-11-29 10:07:52 GMT

Progress! 3 overlay layers using a hybrid trimsheet for the various patterns and text.
2 of the layers are tinted red and black.
The wear on the paint layers is driven by the base material's properties like curvature, height and AO.
#Godot #Shaders #TechArt #Liblast #GameArt
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/565/668/441/179/402/original/0e1f5ccf529ddcb2.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/565/671/803/599/782/original/d9683fe5bdf9c015.png

2024-11-28 19:59:25 GMT

Working on the overlay feature for Liblast's #ubershader.
First prototyped in #Blender, now time to code the shader in #Godot!
- unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/562/294/763/165/405/original/b0479f9578d57fad.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/562/345/770/115/905/original/eb300cd5b7f2c8f3.png

2024-11-17 10:36:01 GMT

- reply

Not quite, this is realtime :D

2024-11-17 10:35:40 GMT

- reply

Here you can find the Terrain3D add-on for Godot 4:
https://github.com/TokisanGames/Terrain3D
And here's NASA data I've used as source:
https://svs.gsfc.nasa.gov/4720
I mapped the color and height onto a UV sphere in Blender, placed a subdivided plane over a small part I liked, used DataTransfer to project UVs from the sphere to the plane.
Then used GrabDoc addon to export textures from the plane.
Imported maps into T3D using the Importer tool (scene) then sculpted over the result using Terrain3D's tools.

2024-11-15 10:40:20 GMT

Terrain3D is an incredible add-on for Godot 4. Thank you @npub1swk…sjth !
This is part of R&D for Liblast and Liblast Framework.
Based on CGI data from #NASA, that was interpreted frivolously to an 8x8 km area and then sclupted over to add detail that was missing from the original textures.
- unfa
#Liblast #IndieGame #Godot #GodotEngine #GameDev
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/486/523/225/613/732/original/c1f3d589ee67d35f.png

2024-10-29 09:24:21 GMT

I'm testing Zulip as a possible hub for the Liblast community:
https://liblast.zulipchat.com/join/fbirc5h2norg6mjdvxjnt7v5/
Feel free to join and test with me :)
Why Zulip and not... Discord?
Because Discord is... ugh. Not a good platform for productivity or privacy.
Also we couldn't ever self-host a Discord server, and it puts limits on us unless we pay.
Zulip on the other hand is happy to sponsor FOSS projects like Liblast, and they have granted us a sponsorship - free hosting.
- unfa
#Liblast #Zulip #Game #IndieGame
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/389/980/995/963/228/original/018d782fce0de0f6.png

2024-10-10 18:10:46 GMT

Finally something new to show off!
Using experience from previous Liblast versions and looking at other FPS-focused game engines I've designed a CVar system for Liblast Framework and it is now operational!
Here's an explanation and demo:
https://youtu.be/rWbq2ZRMqw0
Also - meet yank scally, a new core contributor!
You can test this yourself in the liblast-framework repository:
https://codeberg.org/Liblast/liblast-framework
Roadmap now is to prototype a level and integrate the art pipeline.
- unfa
#Liblast #Godot
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/284/470/173/432/985/original/e985c65cb487c25c.png

2024-10-03 09:42:56 GMT

- reply

Congratulations and thank you for giving these great resources to the community!
- unfa

2024-09-15 22:32:17 GMT

So I wanted to make this for years. And finally I got a good excuse. The effect was pretty neat. Then I came up with the name I want to release it under: "subpixel-perfect"...
When I looked back at my shader using my test card I realized it is far from that...
1.5 days later, it actually is subpixel-perfect!
https://godotshaders.com/shader/subpixel-perfect-display/
Enjoy!
- unfa
#Godot #Shader #Shaders #Pixels #Subpixels #Screen #CRT #TV #LCD
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/143/930/079/140/056/original/db8986e2169c4e2f.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/143/931/128/826/653/original/775a237caba25d8d.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/143/931/682/774/747/original/c7e1a5128ba3331c.png
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/143/939/866/987/076/original/a0297b79ddc61610.png

2024-09-08 22:07:20 GMT

- reply

The access levels I have come up with so far are: core, user, server and client.
core is like root access
user is user prefs, rendering, input etc configuration, customization
server is game logic, mode, balance and cheats
client is lowest security level. This level is for client-side entities or game code.
For example anonymous usage statistics would be writable by all, but readable only by user and a dedicated core service.
- unfa

2024-09-08 22:01:59 GMT

- reply

... as GDScript allows to overload _get(), _set() and _get_properties(), it should be possible to deny direct access to core service variables at runtime.
Methods and cvars will require an access token, which are generated at application start and given to core Nodes. So a script would need to guess or steal a valid access token to read/write/execute stuff that it's not supposed to.
I am still not sure how tight things can be in GDScript, but at least this would enforce using internal APIs ;)

2024-09-08 21:57:59 GMT

Working on Cvars and an internal access control system. The idea is that game components achieve things by talking to Commands and CVars core components. The thing is - you don't want a user to be able to override what a server set regarding game balance, but also - don't want game mods to be able to alter user's preferences that are not related to the mod.
So I'm building an internal system for permissions. Any Cvar and Command will have permission flags, and agents get tokens with privilage.

2024-09-03 00:53:21 GMT

Last 3 weeks of work with Yank is now merged into the main branch.
Fantastic work and I hope we'll clean up the mess of merging everything with ease :D
- unfa
#Liblast
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/070/878/228/689/440/original/c3e03d5673844945.png

2024-08-29 15:30:25 GMT

The #AAA #gaming is stuck chasing highest possible #fidelity at all cost.
Modern "top-shelf" game budgets sit in hundreds of millions of USD.
Yet many claim that the overall quality of games seems to have stagnated if not recessed over the past decade.This cost results in lack of innovation, botched releases, microtransactions, season passes and ever increasing grind. For us developers - also poor working conditions, mass firings and studios dissolving after a single miss...
We can do better.

2024-08-27 13:43:36 GMT

Maybe my CVar question is an X/Y problem?
Needs:
- allow for central managing of game configuration (preferably in a hierarchy)
- allow easy overlay overrides for mutators/mods/AB testing balance changes etc.
- allow to add/edit the values both in the DB and in the scene/script where it's used keeping them in sync
- when var changes, propagate it instantly at runtime
- minimize developer overhead to use this system and code bloat
- add a permission layer so mods can't override certain vars
🤔

2024-08-26 23:53:35 GMT

CVars. How to implement #CVars in #Godot in a way that won't suck..?
I thought: make a CVar class that takes a value (like 100) and an arbitrary unique string(like "balance.player.health") in constructor and it stores that in a project-wide database. If the db has the cvar already, it's read from there instead.
When user uses UI, dev console or a config file to alter the cvar value in db, the CVar object in our script is notified to update at runtime...
Does this make any sense?
- unfa

2024-08-26 11:43:45 GMT

- reply

*part 4*
Yank scally has implemented a replay system prototype that stores/replays a world_state stream w/ scrubbing. This can now be turned into a simple state synchronization networking.
Plan for this is:
- simple authoritative host sync
- client-side prediction
- server reconciliation
- lag compensation for hitscan and projectiles
- game-wide Entity priority to meet net BW/ CPU budget Tribes-style (thanks, Glenn Fiedler!)
- snap. interp.
- profit??
Inspired by Unreal's generilized net model.

2024-08-26 11:37:22 GMT

- reply

*part 3*
instead of Client or Server spawning Game, it's the other way around.
One calls Commands.host() / Commands.join() and gets a ref to a spawned'nconfigured Game node, that itself spawns Client or Server depending on what user requested.
That now will spawn map, chars and set up network sync.
The latter is partially prototyped with a generalized Entity.get/set_state(). Game gathers these and compiles into a complete world_state to be synced or stored (replays, jitter buf).
*verte*

2024-08-26 11:32:51 GMT

- reply

*part 2*
Inspired by the MVC architecture and idTech's command+cvar systems, all game management will be done via the Commands core service.
This way, the UI code will be simpler, an only talk to Commands and CVars, leaving the crucial game-managing logic elsewhere.
Thanks to that approach user should be able to do exactly the same things from UI, console, a script or remote control (SSH?) with no code duplication and a clear flow.
Game replaces GameState to manage map, chars etc.
*verte*

2024-08-26 11:27:04 GMT

Me and yank scally have been co-working via Jitsi Meet and #Syncthing on the #Liblast Framework core this past week.
I think it's taking shape.
I've decided to create a game core and core services which are spawned by the core as nodes and references are kept in a dict. Now anytime something is spawned it's given a dict of these core services references so it can talk to them.
You might think "oh why not just do singletons?" - well, this way I can spoof the references for testing!
*verte*

2024-08-24 14:12:19 GMT

I've been studying popular game engines to see how they organize their "game objects" into classes but also how they structure the whole engine. I've been looking at old Quake, Source, Unreal Engine I (and more recent), now idTech 4 (Doom 3). I have experience working with Unity professionally so that also is there. I see some common ideas, some pitfalls and dead ends, some inspirations... Talked to other programmers and a structure for the #Liblast framework seems to be coming together...
-unfa
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/113/017/399/755/483/142/original/a3a9b3470401cc1e.png

2024-08-18 23:11:00 GMT

And here's a first result of that design work in motion!
- unfa
#Liblast #IndieGame #GodotEngine
https://cdn.masto.host/mastodongamedevplace/media_attachments/files/112/985/546/019/630/093/original/00e70c5afdf85faa.mp4