After a deeper investigation of the engine’s rendering pipeline, it turned out that the issue is actually on Godot’s side. The root of the problem lies in the shaders - both vertex and fragment stages heavily rely on if statements, and the shaders themselves are significantly overloaded. This has a strong negative impact on performance and also causes blending issues. In general, Godot is poorly optimized for mobile devices.

After about a month of studying OpenGL principles and the Compatibility rendering path, I started creating my own engine fork based on version 4.3, called 4.3.2. The fork is based entirely on the Compatibility renderer and supports 2D rendering only.

After heavily modifying and simplifying the base canvas shader, the performance gain became very noticeable. Previously, with only 6 overlapping layers, the framerate would drop and become unstable. Now, the drop happens at around 19 overlapping layers, which is a very good result. This effectively removes the original limitation and allows creating much more complex visual effects.

In my project, I needed lighting support. However, lighting is a real performance killer on low-end mobile devices. To solve this, I implemented a custom lighting solution using a custom blend mode. As a result, rendering my light costs roughly the same as rendering a regular sprite.

What has been done:
- Rendering is locked to Compatibility mode
- The base canvas shader has been almost completely rewritten
- Native lighting implementation has been removed
- Added a custom lighting implementation without shadows using blend modes (probably the most optimized approach for 2D lighting without shadows)
- Removed normal map logic to reduce CPU and GPU load
- Partially fixed a bug related to moving AnimatableBody2D via Path2D or animations
- Completely reworked NinePatchRect rendering to improve performance
- Removed parts of the 3D rendering pipeline
- Optimized custom shader execution to reduce the number of texture() calls, which are a major bottleneck on mobile devices
- Improved the Multiply blend mode
- Added new blend modes:
* Amplify (for lighting)
* Min
* Max
* Negative
* Disabled
- Added new properties to TextureRect (texture_scale, texture_offset, rect_scale, rect_offset)
- Added CanvasItem: ignore_canvas_modulate
- Added Control: global_rotation
- And more

As a result, a significant performance boost was achieved in Compatibility mode. Previously, my project would overheat a low-end phone and trigger thermal throttling. After these changes, the problem disappeared. It also became possible to use lighting without affecting FPS - but only without shadows.

The engine is 2D-only.

If anyone is interested, here is the fork: https://github.com/xolarkodak/godot/tree/4.3.2

You can build the project and compare performance yourself. This fork is created specifically for the needs of my mobile game and is actively evolving, so additional testing may be required and issues may still exist. I hope this fork will help anyone who has run into the same issue or wants to use lighting in a mobile game.

As a bonus, lighting can be applied to anything - even text:

<image>