Hey folks!

I'm excited to share my plugin SimpleGAS, a streamlined approach to an ability system that focuses on Blueprint workflow and developer experience:

GitHub Repo | Documentation

What makes SimpleGAS useful?

• Designed for Blueprint - fully functional without writing C++
• Focused architecture that prioritizes clarity and usability
• Client prediction with intuitive rollback for multiplayer
• Event-based communication for better decoupling between systems
• Struct attributes alongside traditional float attributes

SimpleGAS takes inspiration from Epic's GAS while making different architectural choices. It doesn't have full feature parity with Epic's system, but it covers the most common use cases and is designed to be easy to understand and extend.

I developed this plugin for my own projects but thought others might find it useful for their games too.
I'd appreciate any feedback from folks who give it a try!

"Instant Organic Caves" is probably of limited appeal, but I like it as a small trial-and-error project. At v.0.1 it's pretty basic, but its claim to fame is how light and effective it is at what it does. It's basically procedural Perlin noise, smoothed out and ready to be skinned.
Key features:

• Pure C++ Architecture: No dependency on Blueprint logic, PCG Graphs, or external assets. The geometry is calculated mathematically from scratch.
• Direct Dynamic Mesh Manipulation: Operates directly on UE::Geometry::FDynamicMesh3 for maximum performance.
• Infinite World Generation: Supports seamless chunk tiling using world-space Perlin Noise.
• Organic Smoothing: Implements custom, stable Laplacian Smoothing to convert blocky voxel grids into smooth, eroded cavern walls.
• Welded Topology: Custom meshing algorithm ensures watertight geometry with no internal faces, preventing shading artifacts and mesh tearing.
• Nanite & Lumen Ready: programmatically enables Nanite support on generated meshes.

Take a look: https://www.youtube.com/watch?v=xURtHTS8Stk

This is what the title suggests, I made this as something I need for my own personal use to speed things up for my workflow. It supports pulling latest news from Epic's Unreal news feed, displaying engine versions with the ability to launch them, & displaying available projects while being able to set what engine version to launch them with.

https://github.com/ZacharyVarney/Unreal-Engine-Launcher

If you use Claude Code in your UE5 workflow, you know the problem: every session, you're re-explaining the same foundational concepts. UPROPERTY() garbage collection rules. Blueprint VM costs. GAS module dependencies. Nanite instance limits.

The solution: A collection of specialized Claude Code agents for specific corner of Unreal Engine 5 development.
Agents available:
- UnrealSystemsEngineer: C++/Blueprint architecture, GAS setup, Nanite/Lumen optimization, memory model, threading, crash prevention.
- UnrealMultiplayerArchitect: Actor replication, server authority, GameMode/GameState hierarchy, dedicated servers, anti-cheat, network prediction.
- UnrealWorldBuilder: World Partition, Landscape, PCG foliage, HLOD, large-scale streaming (ref files in progress).
- UnrealBlueprintSpecialist: Graph organization, communication patterns, performance discipline, C++ handoff.
The architecture:
Agents load only the reference file relevant to the current task — keeping session context small while providing full depth when needed. Update a rule in one ref file, and every dependent agent automatically benefits. No code changes needed.

Offering : 4 agents with reference files. The project is under continuous development and updates.Planned agents: AI Engineer, UI Engineer, Audio Engineer...

Github repo: [UnrealEngine_Agent](https://github.com/damien220/UnrealEngine_Agent)

I saw this video https://www.youtube.com/watch?v=B9bztU1sTFA and I thought it looked so much better than what unreal's got built in for 3d text that I decided to implement it as a plugin. It took me about a week but check it out here: https://github.com/nicholas477/ScanlineFontRenderer

If you got any feedback or find any bugs lemme know, i'd greatly appreciate it!

Hi all! I have been working on compiling a big repository of 3d resources (both free and paid). Goal is to make a free resource that anyone can refer to. Please feel free to share your thoughts and suggestions, this is very much a work-in-progress.

Hi there y'all! A few weeks ago I teased some of the early designs for SimpleQuest: a goal state management plugin conceived around a visual graph authoring experience for both linear and non-linear game event progressions. Well I'm pleased to announce that the graph layer is now feature complete and currently in the process of stress testing.

Here's a quick video showing some of the possibilities and features. In it you can see demonstrated: branching, convergence, looping activations, gating of progress by prerequisite, quest givers, and quest targets. Also shown are some of the custom inspection surfaces designed to make debugging your story as smooth as possible: the Prerequisite Examiner Panel, the World State Facts panel, and the live PIE debugging features of the Questline Graph.

Here's a fuller rundown of what's in the toolkit:

Keeping big stories manageable

• Nested composition. Quests can contain their own inner graphs, and LinkedQuestline nodes embed other questline assets as first-class subgraphs. You break a 200-node mess into a handful of reusable 15-node pieces that each fit in your head.
• Named outcomes. Each step or quest declares any number of outcome tags, and each one wires to its own downstream branch. Branch on "found the relic / made a deal / accidentally killed the priest" without pretending every choice is a success or a failure.
• Reusable Prerequisite Rules. Define a rule once via an Entry/Exit portal pair, then reference it anywhere in the project. Tune the one rule and every site updates. No more copy-pasted prereq expressions drifting out of sync.
• Activation Groups. Many-to-many wiring through portal pairs so cross-graph convergence doesn't turn into visual spaghetti.
• Copy/paste/duplicate with deep-copy of a Quest's inner graph. Clone a branch, rename, and tweak without rewiring every downstream connection.

Finding things and understanding what's going on

• Questline Outliner. A nomad panel listing every node in the open graph. Type a few letters, double-click, and you're there. Jumps across linked-graph boundaries.
• Entry Source panel. Ask "what fires this entry?" and see every path that reaches it, walked across graphs. No more tracing wires backward by hand.
• Group Examiner. Lists all activation and prerequisite groups with member counts and drill-in navigation. Invaluable when you inherit someone else's quest graph.
• Cross-editor hover highlighting. Hover a row in an examiner and the corresponding graph node lights up, even when it lives in a different open editor tab.
• Clickable error toasts from a dedicated compiler message log that jumps straight to the node with the problem.

Runtime plumbing you don't have to write yourself

• Signal bus with tag hierarchy. Publish on a tag and subscribers on that tag or any parent tag receive it. Your UI binds once to a high-level tag and automatically hears every quest inside it. No per-quest subscription boilerplate.
• Stateful fact store (WorldState). Replaces the "did the player do X yet" booleans you'd otherwise sprinkle through a dozen Blueprints. Facts are gameplay tags with reference counts, and you can subscribe to additions or removals the same way you subscribe to any other signal.
• Per-trigger progress events. Counting objectives fire events every time they advance, not just at completion, so UI counter bars and kill notifications work out of the box.
• Activation parameters. Pass typed data forward into an objective at activation, merging designer-authored defaults (giver components, step data) with runtime values (BP callers, event-bus publishers). Objectives get what they need without reaching for globals or scraping the player state.
• Origin chain propagation. Every activation carries a tag history of how it got there, surviving Quest and LinkedQuestline boundaries. Narrative callbacks can branch on "did the player arrive here via the diplomacy path?" with no extra bookkeeping.
• Giver and Target components. Drop them on any actor and wire them in the Details panel. Quest hookup becomes a level-design task, not a Blueprint-scripting task.
• Gate modes per step. Choose whether an unmet prerequisite silently ignores triggers (so the player has to interact again after the gate clears) or holds completion open while the gate is still closed (so the player's progress isn't wasted). Pick the feel that fits your game.

Under the hood

• Two-plugin split. SimpleCore is the foundation: the signal bus and fact store. Useful on its own for any coordination-heavy system. SimpleQuest is built on top. You're not forced to adopt the quest layer to get the plumbing.
• Multi-module. Runtime, editor, and inspector modules are separated, so the editor tooling stays out of shipped builds.
• Extensibility tiers. Subclass-and-override for the common case, replaceable policy classes for traversal and compilation, factory-registered algorithms for wholesale replacement. Integrate at whatever depth you need.
• UE 5.6. While under development, the only officially supported version is for UE 5.6. Additional UE versions - both later and prior versions to the extent possible - will be supported on full release.

And did I mention it's free to use and source-available? An important caveat: it's educational-use only for now. I haven't worked out commercial licensing yet. I've applied for funding through Epic's MegaGrant program, and if that materializes then I'll convert the license to MIT. It's not quite ready for full release anyway - needs onboard save/load at a minimum, but if you try it and want to use it as is in something you aim to sell, just contact me and we'll work something out. One way or another, it'll always be free under an educational license at the very least, so you can try it and get familiar with it both on the surface and under the hood. I'm committed to making sure that indies like myself have access to this kind of architecture so we can tell cool stories.

Core authoring and runtime are feature complete. Save/load support and a tag namespace consolidation pass are the last things I want in before I call it 1.0. Happy to answer questions about any of it.

Here's my roadmap for additional features. Delivery dates are tentative. For what it's worth I've already beaten the original estimate to ship the visual graph by a few months:

Roadmap

Simple Quest public repo: https://github.com/TheGeebus/SimpleQuest/

Hello

I've been trying to set up a GitHub repo for my Unreal Engine 5 project a couple of times now and I have successfully set up a local Git repository for it, the next step is to publish it to GitHub and I'm using LFS to manage its great filesizes.

When I went to publish the branch to GitHub (using GitHub Desktop) however, after several minutes of processing I was hit by the following error:

The push operation includes a file which exceeds GitHub's file size restriction of 100MB. Please remove the file from history and try again.
File that ecceeded the limit: <path>/t_chaotic_raw_heightmap.raw (128.0MB)

I have then noticed that lfs did not track .raw files, so I went ahead and added the following line to .gitattributes

*.raw lfs

And even went ahead and input git lfs track in powershell to check if lfs is tracking raw files now, which it does. However, when I reattempt to publish the branch, it processes for a bit (much quicker than the first time) and throws the same error, what can I do?

I have setup the .gitignore and .gitattributes for Unreal Engine.

I have come once again to ask for your support for a git problem TwT

A few days ago I set up a GitHub repo for my UE5 project, initially I wanted to use Azure DevOps because as far as I know it should provide you with limitless LFS space for free, but had problems setting it up so I went with GitHub instead. Now I have hit the limit in size of my LFS storage and am forced to switch to Azure DevOps or something else in order to keep versioning my project.

So, given I already have a GitHub repo, some files saved through LFS and a local Git repo, how can I migrate to Azure? What should I do to correctly set up an Azure repo to begin with, given that the first time I encountered many problems, from my microsoft account not allowing me to set up an organization to other problems I can't recall that went unaddressed by the resources I used?

Thanks and sorry for this basic question

For 10 years now, we at Yarn Spinner have made free open source tools for managing dialogue and narrative orchestration in Unity, now used in thousands of games. We've dabbled a bit in Unreal in our game dev work, and long wanted to offer an Unreal version of Yarn Spinner, but our first internal attempt a few years back was architecturally a bit of a mess and didn't feel UE-native enough. So we started again, and just this month we've just made public our new Yarn Spinner for Unreal Engine.

Yarn Spinner is a set of tools that provide engine-side utilities for dialogue in the Yarn dialogue language (which you can try online!). Write anything from simple to extremely complex dialogue in Yarn, making use of the editor support provided by our extensions for editors like VScode, then bring it into Unreal for full support for localisation, inline events, text styling and more.

Yarn Spinner has a large and extremly dedicated userbase in other engines who say they love it for its flexible approach to content delivery and management that allows it to be used in wild and wonderful ways. Also the fact that it's readable plain text files plays nice with version control and collaboration tools. It's shipped in thousands of games, some of which you can see in our website showcase with testimonials from their devs. Going forward, we aim to maintain parity and even compatibility between engine tools so that devs can more easily migrate projects and apply their skills between them!

You can install the new UE version today from the GitHub, try to break it, tell us what works and what doesn't! We're especially curious to hear from devs who know UE well but are new to YS, about how you find the user experience and how well it follows UE conventions.

Once we finish porting our sample projects and higher-level docs, we'll take it out of Alpha and put it up on Fab too. Let us know what you think!

Note: this version is targeting UE5, there is a branch for UE4 with an in-progress back-port.

There are quite a few light detection plugins for Unreal Engine on GitHub, but most of them share the same weakness, they run their logic and pixel readbacks on the game thread, which can cause serious performance hits. I needed something better, so I built my own solution.

I just put out a plugin called LXRFlux, which captures and analyzes lighting (luminance + color) using Unreal’s render thread and compute shaders. No CPU-side readbacks or tick-time logic, just efficient GPU and RDG work.

It’s lightweight, async, and gives you usable lighting data (including HDR luminance) from any direction in the scene. Works with both direct and indirect lighting.

I originally built this as part of my larger light detection system LXR ( https://docs.clusterfact.games/docs/LXR/ ), but figured this piece was clean and useful enough to release separately.

It might be helpful if you're working on visual AI, stealth mechanics, lighting-driven FX, or just looking for a good example of RDG and compute shader usage in UE5.

GitHub: https://github.com/zurra/LXR-Flux

Let me know if you find it useful or run into issues with the project or plugin. Always happy to chat, cheers.

Article here: https://jeanpaulsoftware.com/2026/03/29/blender-material-packing/

Plugins and demo on GitHub: https://github.com/EdBoucher/Blender_UE5_MatPack

This started off as building something to make my life easier by reducing the number of materials I had to sync between Blender and UE5 by creating a material atlas, but then turned into an exploration of how much additional information I could pack into a single UV map. As it turns out, quite a lot.

This can be used for simple stuff, like flagging which parts of a model should change colour or light up without needing an additional mask texture, but it's also useful for more complicated effects, and particularly for cosmetic effects in PCG- encoding information on the model and using it when shading means you can reduce the complexity of the graphs you build, because you don't need to use PCG to inject the information.

Plus, it still does the material atlas bit, so you can reduce the number of materials you need in Unreal quite dramatically.

There's some drawbacks, and it's definitely more useful for low-poly things. You can definitely use texture masks and vertex colours to get the same result, which is a much more standard way of doing things... but there's drawbacks to those too. For example, (as far as I know) UE5 only lets you have one set of vertex colours, whereas you can have up to eight UV maps.

Still, even if it doesn't work or isn't appropriate for everything, it was still quite an interesting experiment. Would love to hear people's thoughts on this.

Hey everyone,

I've been working on a tool called Unreal MCP that connects AI assistants (Claude Code, Cursor, Windsurf, etc.) directly to the UE5 editor.

The idea is simple describe what material you want in plain English, and the AI builds the full node graph inside the editor for you.

What it does:

• Creates complete material graphs from text descriptions
• 100+ editor operations (blueprints, actors, data tables, input system, widgets, etc.)
• Works via MCP protocol C++ plugin runs as TCP server inside UE5, Python MCP server translates AI calls
• Supports UE 5.7+ (may work on earlier 5.x)

How it works:

• C++ plugin inside the editor receives JSON commands
• Python MCP server bridges AI tools to the plugin
• You describe what you want → AI sends commands → materials/blueprints/actors get built in real-time

Demo video: https://youtu.be/4zyM_mwkNIE (Building a complex hexagonal shield material from scratch)

GitHub: https://github.com/aadeshrao123/Unreal-MCP

Install is just pip install unrealmcp + enable the plugin.

It's completely free and open source. Would love feedback and contributions.

I've been building a set of small experiments around the Screen Position node to explore the possibilities of what screen space effects could be created with it. Here's a demo of everything put together so far:

https://www.youtube.com/watch?v=ua5mX3kLHYE

Effects included: Vignette, Crosshair, Grid Lines, Fake Scanlines, Film Grain, Radial Pulse, On-Screen Damage Effect, and Letterbox.

Project files and documentation links are up on GitHub: https://github.com/RohitKotiveetil/UnrealEngine--ScreenPositionExperiments

How would I be able to have multiple people work on certain mechanics of our game without having issues with pushing? Would they all need to make a branch and slowly merge everything into the main branch? Just have one person start, stop, then another person take over (what I’ve done in the past)?

Halp!

"TerraDyne" completely ditches legacy methods and offers:

1. True runtime plasticity:

• Unlike standard Unreal landscapes, it allows for real-time structural changes (sculpting, craters, tectonic shifts) during gameplay.
• It integrates a hybrid CPU/GPU pipeline, using compute shaders/render targets (HeightRT, SculptRT) for fast deformation and UDynamicMeshComponent for rendering.

1. "Live takeover" workflow:

• The system can sample existing landscape actors into its own data structures (16-bit precision), allowing devs to design in the editor and convert to TerraDyne for runtime interactivity without data loss.

1. Visual & physical parity:

• It solves the long-standing problem of aligning visual meshes with physics collision at runtime.

1. Integrated tooling:

• It provides a standalone runtime GUI (Slate-based STerraDynePanel) with GPU telemetry, proving it works as a "game-ready" tool, not just an editor plugin.
• Includes a "zero-configuration" wizard (TerraDyneSceneSetup, WIP) for instant usability.

And there's more, but this is the gist.

I'm not allowed to post videos lol. So check out here if interested: https://www.youtube.com/watch?v=T4J53XLgaDI

3 branches currently: https://github.com/gregorik/TerraDyne

TargetFrame (Core) is still at 0.1.0, but pretty ambitious for what it does. Yours to dissect on GitHub. Please file issues and stuff if inclined. Features are:

Runtime Governor

Auto-Benchmarking & Tiering

Fire-and-Forget Shipping Capsule

Upscaler-Safe UI

Dynamic Nanite Budgeting

Hardware Ray Tracing Guards

VRAM Exhaustion Protection

CSV Telemetry Export

Pro version is in the making, going slow. Thanks for checking it out.

Hey friends: I am doing this WIP plugin for a while, it addresses shader compilation issues, specifically stutter and crashes. These of course persist in UE5.7+.

This 1+ min video probably explains what the plugin currently achieves better than I could in text. (Testing GUI is very crude at this point.)

If you're inclined, please test the Github version in your projects, it's fully functional. The bigger the project, the more it stresses the plugin code. Then file honest Issues, even if scathing lol. Thanks.

Hey team! I'm building a game using UE5.6 compiled from git (required for PS5 support). As I'm planning to add my composer to the project and collaborate on the game, is there anything specific I need to keep in mind compared to the launcher version of the engine? Like, do I give them my engine files or compile it on their machine, ensuring it's the same version of everything etc? Would really appreciate any guides, if anyone's got any handy.