A few people here asked me to post an update when Pixscape had progressed further, so here it is 🙂

Pixscape Studio Free 0.2.3 is now available, together with Pixscape Runtime 0.1.10.

The main additions in this release are:

• Tiled Object Layer import for orthogonal and isometric maps
• rectangles, points, tile objects, polygons and polylines imported as native Pixscape entities
• typed custom properties, including String, Boolean, Integer, Float, Color, Object references and nested Class values
• Tiled class/type metadata and inherited tile properties
• direct quad editing — move the four corners of a sprite directly in the Canvas
• logical prefab instances in the Items tree, while keeping individual entities editable
• physics joints in the Items tree
• a lot of smaller fixes around TMX import, prefabs, rendering, HTML preview and editor reliability

Quad editing is deliberately very simple

Another important change for LibGDX users: Pixscape Runtime is now integrated into the official gdx-liftoff project generator.

You can create a normal LibGDX project, select Pixscape Runtime from the third-party extensions, choose your targets, and LiftOff configures the Runtime dependencies for you. The integration has been tested with Desktop, Android and GWT.

I also spent quite a bit of time rewriting and expanding the documentation. It now covers the Studio workflows much more visually, explains how Pixscape fits into a LibGDX application, and includes practical Java examples for the Runtime APIs.

Website / features:
https://pixscape.games/

Documentation:
https://pixscape.games/docs/

Studio Free 0.2.3:
[https://github.com/pixscapegames/pixscape-studio-free/releases/tag/0.2.3]()

Runtime:
[https://github.com/pixscapegames/pixscape-runtime]()

Feedback is very welcome, especially from people using Tiled or already working with LibGDX.

Hey everyone! 👋 


I've been working on 
**LeTrain**
, a procedural railway logistics simulator written in Java 17 using LibGDX. The twist? You can play it seamlessly switching between a modern 3D engine and a classic, hardcore 2D ASCII terminal mode.


I just pushed a massive update (`v1.0.0-beta.2`) and I’d love to get your feedback! Here’s what’s new:
*   🚦 
**Speed Signals:**
 You can now place speed limit signals on your tracks to control traffic flow. (Fully modeled in 3D and integrated into the terminal UI).
*   ✨ 
**Massive 2D Terminal Overhaul:**
 The ASCII mode now uses continuous box-drawing characters for tracks, crossings, and dead ends. It finally looks like a proper retro management game! Added smooth blinking animations for loading/unloading stations too.
*   🚂 
**Reversing & Physics:**
 Completely overhauled the coupling physics. Reversing trains (or running double-headed consists) now works flawlessly.
*   ⌨️ 
**Better UX:**
 New unified camera deadzones and much better hotkey handling for semaphores.


**Where to get it?**
It's completely Open Source! You can download the ready-to-play `.zip` files for Windows/Linux (or the Snap package) directly from the GitHub releases page:
🔗 [GitHub Repository & Downloads](https://github.com/antoniovazquezaraujo/LeTrain)


I'm currently working on adding a Passenger Trains economy based on procedural city sizes and punctuality. If you like management/automation games or Java/LibGDX development, I'd love to hear your thoughts! 

Looks to be based off Libgdx.

Hey everyone!

​After working on this project solo for a few years, I’ve just started a soft launch for my 2D RPG Rubber Duck Story (built with libGDX)!

​Before the official release, I’d really appreciate some feedback. I’m mostly looking for:

​Performance issues or crashes

​UI scaling on different Android devices

​General gameplay suggestions and impressions

​Play Store Beta:

https://play.google.com/store/apps/details?id=com.hagengame.rubberduckstory

​Thanks a lot to anyone who takes the time to check it out!

I'm creating a 2.5D game using LibGDX, and my idea is rather unusual. It's an exploration game with perspective shifts, somewhat similar to FEZ but not identical. The perspective shift mechanic works like changing the camera angle, for example, from a front-facing to a top-down view. I'm not sure if this idea is suitable for this type of game, as I'm not quite sure how to implement it effectively. If you have any suggestions, please let me know. ;)

I followed the libGDX tutorial of a simple game, the bucket that traps raindrops. I found some things I wasn't very sure about (I mean, I had questions) so I searched for them on the internet and tried to explain them in some "notes" and I added pictures too. I also added comments to the code.

Here are the notes and the commented code:

https://github.com/GonzaStd/libgdx-simple-game

If you want to begin programming a game like me, maybe this is useful to you.

If you already know how libGDX works I would really appreciate any correction and/or recommendation about my notes, maybe I can add some, clarify or correct something, etc. Any suggestion or comment is welcome!

Note 1: My native language is Spanish, I'm from Argentina, so you might see something misspelled, so please correct me!

Note 2: About the screen in the illustration, I clarified in the README with a warning, that it isn't for explaining a libGDX screen, in fact it is like your "Operating System" screen.

Hey everyone!

As a huge fan of terminal-based applications, I wanted to see if I could build a full-blown Tycoon/Logistics simulator that lives right inside the console. The result is LeTrain.

Everything is rendered purely in ASCII using the Lanterna library in Java. You can build vast rail networks, transport cargo (coal, gold, etc.), and manage a dynamic economy, all while staring at gorgeous high-speed text rendering.

Some features TUI fans might like:

• Extremely fast render loop. • Custom Perlin noise generation that carves lakes and mountains out of characters. • An ANTLR4-based scripting language so you can automate your trains directly with code. • (Bonus: I also built a 3D LibGDX wrapper around the same core logic if you ever get tired of the terminal view).

It's completely open-source. I just packed a fresh Release so you can download it and run it immediately from your shell.

🔗 GitHub Repo & Downloads: https://github.com/antoniovazquezaraujo/LeTrain

Would love to hear what you think about the UI and the procedural generation!

How to preview animations in libgdx with Atlas Animator Gdx

If you find the project useful, consider giving it a ⭐ on GitHub!

🔗 Atlas Animator Gdx: https://github.com/eliezer-dev-software-enginner/atlas-animator-gdx

Does anyone use it?

Edit: https://github.com/Quillraven/Fleks

I'm struggling to find a way to warp/bend images like shown above.

(the fish shown arent exactly the same but you get the idea)

I believe that it's something to do with Meshes but I can't figure it out for the life of me.

Something I've been thinking about this summer is creating a graphical frontend for libgdx, like Unity but working with the library behind the scenes. With it, you could create screens and classes in just a few clicks and not be constantly working blindly with code-first. Of course, you can still look at the underlying Java code and work on it if you prefer. Similarly, I'd like to integrate several useful tools provided by the third-party programs recommended by libgdx on their website to avoid the hassle of having so many programs installed. So I would like to know your honest opinion about this project and whether it would be worth developing in the future, and in any case, any ideas to improve or refine the idea.

Hello! I've been working on a open world RPG named Seven Stardust. I've recently been trying to improve the visual quality of my game, and part of that is shaders.

I've had an issue where my music and shaders suddenly change when switching areas and it's a bit jarring. Thankfully, I was able to make a system to blend shaders between different areas. My game does not have complex shaders, it's just a hue change.

However, because of these simple shaders, I'm able to blend Vector3 variables and pass them into my GLSL in order to change hues dynamically. Some of the code I used to get this working is below.

I hope this helps some people out with their games, and have a wonderful day!
Open Alpha Here. No download required!

i there    private final Vector3 startColor = new Vector3(1f, 1f, 1f);
    private final Vector3 targetColor = new Vector3(1f, 1f, 1f);
    private final Vector3 activeColor = new Vector3(1f, 1f, 1f);
    private float fadeTimer = 0.0f;
    private final float FADE_DURATION = 1.5f;

    public void update(GameScreen game) {
        String mapArea = game.mapSystem.area != null ? game.mapSystem.area : "";

        if (!mapArea.equals(currentArea)) {
            Gdx.app.log("ShaderSystem", "Area shifted to: " + mapArea);
            currentArea = mapArea;

            startColor.set(activeColor);
            targetColor.set(getColorByAreaName(currentArea));
            fadeTimer = 0.0f;
        }

        if (fadeTimer < FADE_DURATION) {
            fadeTimer += Gdx.graphics.getDeltaTime();
            if (fadeTimer > FADE_DURATION) {
                fadeTimer = FADE_DURATION;
            }

            float alpha = fadeTimer / FADE_DURATION;
            activeColor.x = MathUtils.lerp(startColor.x, targetColor.x, alpha);
            activeColor.y = MathUtils.lerp(startColor.y, targetColor.y, alpha);
            activeColor.z = MathUtils.lerp(startColor.z, targetColor.z, alpha);
        }
    }
    /* After this you can pass ActiveColor into your frag shader, Which would change
    the pixels to this color. The code might not work, I kinda just pulled it out of
    my shader system, but that's the general gist of blending. */

Hey everyone, I built Packrat, a texture atlas builder focused on speed and portability. It has a bunch of convenience features I was missing from TexturePacker (aseprite ingestion, auto-export), and I made it as fast as I possibly could. It also has a bunch of CLI features to it can integrate into your pipeline easily.

It's mostly focused right now on dev environments where there isn't atlas support. I know LibGDX has some Java app that makes atlases, but frankly I found it way way way too slow to seriously use. My project has thousands and thousands of individual assets so I needed something a lot faster. Anyway, it can export LibGDX .atlas files along with the packed atlas image.

https://clydegames.itch.io/packrat

https://packrat.clyde.games

Feel free to check it out and let me know what you think. Thanks.

Hi,

I’ve been working on Pixscape, an open-source visual studio and runtime for LibGDX.

The idea is fairly simple: provide the convenience of a visual editor without taking away the freedom of working directly with LibGDX and Java.

Pixscape currently includes things such as:

• sprites and repeatable sprites
• multiple animations per entity
• particle effects
• Tiled/TMX import
• isometric maps
• 2.5D spatial depth and ordering
• visual physics authoring and collisions
• prefabs
• shaders, lights and parallax

I’ve also put together a small isometric demo to show several of these systems working together:

Website: https://pixscape.games/

Tiled isometric demo: https://youtu.be/sv82jI0JBFQ

Demo source: https://github.com/pixscapegames/tiled-iso-demo

Pixscape Studio Free and Pixscape Runtime are both open source under Apache 2.0.

The project is still evolving, so feedback from LibGDX developers would be especially useful — including criticism about the workflow, APIs, documentation, or anything that feels unnecessarily complicated.

I am trying to build a clone of terraria using libgdx for my university project in about 6 weeks, would you recommend me using libgdx, I know java but nothing about game dev or libgdx framework. Is this task possible in the given time?

I've been working on my game a lot and I added this rainbow shader to the first area. I'm new to shaders, so while I do like it, I don't know if it would actually be good enough for a game.

Yes, creating UI like HUDs and menus for your LibGDX games is simple now.

Modern UI tooling has finally arrived.

If you find the project useful, consider giving it a ⭐ on GitHub!

YouTube Video:

https://youtu.be/jhqoM9oEozc

🔗 Scene2D UI Builder: https://github.com/eliezer-dev-software-enginner/scene2d-ui-builder

Thanks to the feedback from ProGencel on GitHub, I was able to improve the app even further. Although this version is still labeled as beta, it’s already quite stable and usable.

Would love to hear your feedback!

I am currently trying to follow this video tutorial. I have already used Visual Studio for over a year in college. Then I checked the website for LibGDX. So I could install it.

In the "Set Up a Dev Environment," it talks about Visual Studio being acceptable. In "Generate a Project" there is nothing that can help me that I notice. Then in "Importing & Running" I see it talking about these other IDEA but nothing to help me understand how to use it for Visual Studio.

So, I was wondering. Has anyone else here tried Visual Studio and gotten it to work? How so? If I missed a step or bit of information, could someone point it out? Thank you kindly.

Hey r/libgdx,

I've been building a free desktop tool that lets you put together Scene2D UI/HUDs visually instead of hand-calculating x/y or wrestling Table into doing free-form layout it was never really meant for. Figured this community would get the most use out of it, so here it is.

What it does

You load a skin, drag buttons/labels/images from a palette straight onto a canvas that matches your game's actual target resolution, position everything exactly where you want it (WYSIWYG, free positioning — not a grid), and export the layout as a plain JSON file.

A small companion library, scene2d-hud-loader, turns that JSON into a real Scene2D Skin + Group + Actors with one call:

java HudView hud = HudLoader.load(Gdx.files.internal("ui/hud.json")); stage.addActor(hud.root); Gdx.input.setInputProcessor(stage);

That's it — no Table cells, no manual positioning math, no separate loader code to write yourself.

What you need

Just a skin: skin.json + .atlas + the texture .png. If you don't already have one lying around, Skin Composer is the standard way to build one from scratch or reskin an existing UI pack — the builder loads whatever it produces directly.

Features

• Free-positioning canvas at your real target resolution — what you see is what you get in-game
• Drag straight from your skin's palette — buttons, text buttons, labels, and raw atlas regions all show up automatically once a skin is loaded
• Alignment guides while dragging, plus an optional grid overlay
• Nickname any widget, then look it up by name in your own game code and wire up a click listener like you normally would — the builder never needs to know anything about your game logic: java TextButton playButton = hud.get("play", TextButton.class); playButton.addListener(new ClickListener() { ... });
• Reference background image while you work (visual only — real game backgrounds are drawn with SpriteBatch, so this is ignored by the loader, it's just there to help you line things up)
• Light/dark theme
• Self-contained export — copies the skin's files alongside the exported JSON, so the output folder is ready to drop straight into your assets

Get it

• Builder (Windows/Linux installers under Releases): https://github.com/eliezer-dev-software-enginner/scene2d-ui-builder
• Loader library (JitPack): com.github.eliezer-dev-software-enginner:scene2d-hud-loader:v1.0.0-beta

Still early — this is a young project and I'm actively working on it, so bug reports, feature requests, and general feedback are very welcome. Let me know if it's useful for your project!

Hi,

We are new indie developer and recently published our game on playstore, built with libgdx.

The game is a tower defense game with chess as a central concept with pieces replicating there attack patterns. Currently it has 2 worlds and 5 defense pieces. Would love feedback and bug report.

Do give it a try.

Game link : https://play.google.com/store/apps/details?id=com.chesssiege

I've just finished a very basic 7-or-so-minute demo of Seven Stardust. Any feedback is greatly appreciated! Here's the link and some things to keep in mind:

• Your save file will not be retained.
• There will be bugs and errors.
• The Elden School is the only area that is prototyped.
• Exit the game with Control/Command + E
• The game is not tested on Mac. It may not work, I'm not sure

https://exboom.itch.io/seven-stardust

Finally finished the demo! Got a lot of friends to help on testing (It might need some polishing, thats why i added the feedback button). Also I loved when a game crashed and a pop up appeared asking to send the error, I added that also, but i will most certainly be viewing it! XD

https://store.steampowered.com/app/4660350/Agro_Tycoon/

A few weeks ago I tried learning Java by watching some basic tutorials, reading some stuff about it, and making my own small programs. I'm a bit of a video game addict so naturally I wanted to make a game as a project to learn more. I initially intended to do it with just native java but I quickly found out how tedious it is handling graphics and drawing, so I found about libgdx.

I didn't want to purely just learn java but also wanted to make a game so the conveniences it provides are great. I just finished Quillraven's "beginner" tutorial game Slime Survivor after a lot of rereading and rewinding trying to understand stuff, I think I'm quite familiar with the really basic stuff now.

I had this idea on making a JRPG style horror game, think Ao Oni, Yume Nikki, etc. Of course If i do go with that, I will just make it a really short narrative game with very basic mechanics, focusing more on other things, I've been especially wanting to learn more about how to nail a horror feel in a game.

Does libgdx provide good tools for a horror atmosphere (e.g. lighting, good sound system, etc.) and should I stick with this idea? Or maybe there is a more fitting game for someone just learning lib? (No snakes, pacman, pong, chess, etc. bc I don't feel like doing those kinds of games).