What's New?
Over the past few months, most of the development has been focused on C# scripting. Many changes were introduced, primarily aimed at simplifying development and improving compatibility with various NuGet packages. The focus shifted from visual programming towards improving the user experience when working with scripts. The goal is to make it as easy and intuitive as possible to create mini-apps that do something useful — whether it be a small automation tool or a full-fledged bot. Under the hood, they will leverage the full power of EyeAuras, but on the surface — it's entirely up to you.
To support this, there's already a powerful feature set:
And that’s not all — crypto payment support and full UI hiding will be added soon, along with many other improvements. The mission is to drastically reduce the time between having an idea and getting your app running on a happy user's machine.
I believe mini-apps may become the primary way to fund the rest of EyeAuras development (discussed below). Time will tell how accurate that assumption is.
Nothing bad! Yes, upcoming months will likely be script-focused, but the roadmap includes:
This includes auras, triggers, and actions. The annoying lags when switching auras will finally be gone. Load times will improve by ~3–5 seconds. This migration will take about one year.
We already have Auras, Macros, Behavior Trees, and Scripts. Each has its strengths: Trees for bots, Auras for small automations (e.g., auto-pots), Macros for predefined action sequences, and Scripts as a universal hammer.
But there’s always room to grow. Inspired by Unreal Engine Blueprints, we aim to create a new visual programming tool: Blueprints. The idea is to place Auras and logic blocks on the same canvas (similar to BT editor) and define interactions between them — reactions to aura triggers, execution sequences, event logic, loops, etc. You can also call BTs and Macros from within.
This will take months, but initial prototypes may appear later this year.

This is the logical evolution of mini-apps — but with your app as the primary product, and EyeAuras becomes a toolkit.
Want to capture the screen? Done. Simulate input using 10+ methods? No problem. Embed C# scripting so users can write their own automation logic? Yes — EyeAuras scripting is now a standalone, mature engine.
Every capability in EyeAuras is available as a plug-in module.
The technical challenges have been solved. Early SDK versions can already be used in C# projects via NuGet. Licensing/distribution details are being finalized. The SDK will be commercial — one-time purchase, use it however and as much as you like. It will be a fully autonomous product, not tied to EyeAuras infrastructure.
Expect more info in the second half of the year.
📎 More info, examples, and scripts — here
DMA (Direct Memory Access) is a technology that allows reading or writing data directly to computer RAM without involving the CPU or OS. This makes it possible to access any process’s memory, even those protected by anti-cheat systems or technologies like Kernel Patch Protection (KPP), HVCI, and user-mode hooks.
ReadProcessMemory
, but behind the scenes, you’re talking directly to the PCIe bus.All of this is now available in the familiar EyeAuras scripting model — no need for HDL, PCIe knowledge, virtualization, or drivers.
IMemory
and IProcess
APIsNative ImGui integration is in progress — a modern, imperative-style UI option to complement the existing Blazor model.
ImGui ("Immediate Mode GUI") is a fast, lightweight UI library designed for tools in game engines. Used in many AAA editors, it’s known for its speed, ease of use, and live updates every frame.
In EyeAuras this means:
.csx
Here's an example (also covered in the guide):
AddNewExtension<ImGuiContainerExtensions>();
var osd = GetService<IImGuiExperimentalApi>()
.AddTo(ExecutionAnchors);
osd.AddRenderer(() =>
{
ImGui.Begin("My UI");
ImGui.Text("Control window flags and interaction behavior.");
var isActive = Trigger.TriggerValue ?? false;
if (ImGui.Checkbox("Is Active", ref isActive))
{
Trigger.TriggerValue = isActive;
}
ImGui.SameLine();
ImGui.TextDisabled("(Gets/Sets whether Trigger is active or not)");
ImGui.Separator();
if (Trigger.IsActive == true)
{
ImGui.TextColored(new Vector4(0f, 1f, 0f, 1f), "Trigger is currently ACTIVE");
}
else
{
ImGui.TextColored(new Vector4(1f, 0f, 0f, 1f), "Trigger is currently INACTIVE");
}
ImGui.End();
});
Now you can build truly standalone mini-apps inside a single .csx
file.
Usb2Kbd
is a hardware input emulator supported in EyeAuras since ~2021.
Now you can build your own for about $10 using an inexpensive board from AliExpress or Amazon.
Here’s a detailed step-by-step guide: Russian / English
The backend has also been improved and the settings window redesigned for a better user experience.
All action nodes (e.g., Wait, MouseMove, KeyPress, etc.) now support outputs. The linked node is executed only if the current one succeeds.
You can now set Target Window
and Input Simulator
for each tree or macro individually. As before, properties can still be set at the folder level — this adds flexibility, not a replacement.
You can now reference another Aura containing a C# Script
action — similar to referencing a different project in software development.
All types and classes defined in that script become available for use in your BTs or Macros.
This feature has been around for a while but was previously hidden from public view as it wasn’t stable enough.

Now you can define a C# class that analyzes the game — via memory or CV — and feeds data into your Behavior Tree. Instead of cluttering the BT with dozens of variables and conditions, you can encapsulate all logic in a single class (e.g., TheGame
).
Example bot that uses this model
More info here
Here’s a typical Razor component from before:
UserComponent.razor
@namespace GameGrind
@inherits BlazorReactiveComponent
<!-- your Razor/HTML code -->
UserComponent.cs
namespace GameGrind;
public partial class UserComponent : BlazorReactiveComponent {
// some code
}
That namespace (GameGrind
) used to be autogenerated, making it hard to copy/paste between scripts without conflicts.
Now, namespace declarations are optional — EyeAuras injects them at compile time. Less code = fewer headaches.
Fixed an issue with ComputerVision API
not loading models/images via HTTP. Two example bots were added:
This example shows how to:
ComputerVision
to find images, run ML, OCR, etc.SendInput
to simulate user inputOnScreenCanvas
to draw overlays
Same as above, but uses ImGui for UI and overlays.
.NET is the platform that powers EyeAuras. .NET 8 was chosen due to a new memory manager prototype that outperforms all previous versions.
EyeAuras traditionally prefers increased memory usage for higher performance, so a fast memory collector isn’t a luxury — it’s a necessity. This version still uses the older GC, but once the new GC is stable, it will be enabled.

The editor now uses the new UI framework — faster and more responsive.
Old Version:
New Version:
Macro rendering has been significantly reworked. You’ll notice the difference especially in large macros (50+ nodes). More updates are coming.
This long-standing bug caused panels to overlap — most notably C# Action overlapping Event Log. It’s known as the WPF Airspace issue and has existed for over 12 years. In Microsoft’s UI stack used by EyeAuras, it’s been around since July 2020.

After years of waiting, Microsoft finally fixed it. There was no real workaround, so we had to wait.
This fix is not just about better UI on small screens — it unblocks the long-awaited migration of triggers/actions to the new UI. Previously, everything had to be rewritten at once. Now, it can be done gradually — much more manageable.
PoeShared.Blazor.Controls
exposed by default (e.g. ReactiveButton
)ReadManaged<T>
— slower than Read<T>
, but honors MarshalAs
ReadExports
now returns human-readable export name along with mangled symbolPutting this in separate section as probably all users of EA at one point of another seen that problem - you resize one of the panels and it starts overlapping with another, the most usual scenario is C# Action overlapping with Event Log.
This bug is known WPF Airspace issue and was known for at least 12 years. Specifically in the Microsoft UI framework that EyeAuras uses, it has been there since July 2020[https://github.com/MicrosoftEdge/WebView2Feedback/issues/356]
Ano now, finally, after years of waiting, this has been fixed by Microsoft. Yey. Unfortunately, this has been one of those issues which are very hard to fix on application-side, so I had to just wait.
This fix is important not only because now UI is more convenient to use on lower resolutions, but also it was a huge roadblock on migration of triggers/actions to a new UI framework. Before that the only viable approach was rewriting ALL of the triggers and actions in one go, I could not work on them on a 1-by-1 basis. As you can imagine, this is not really doable - full rewrite would take months of writing the code which nobody uses and then putting it all at once. Number of bugs would be stunning.
And now, I can start rewriting triggers/actions gradually. Rework will still take months, but it is doable.
ReadExports
now returns human-readable version of export alongside with original name, e.g. ?StaticClass@UGameEngine@@SAPAVUClass@@XZ
-> public: static class UClass * __cdecl UGameEngine::StaticClass(void)
Fixed the problem with ComputerVision API not resolving models/images via HTTP links and created two examples:
In this one I am showing how to:
Realistically, these three combined are more than enough to create a bot :) All the tools are right there in the box.

Verrry similar to the one above, except for a fact that it uses ImGui - immensely powerful drawing library that could be to create UIs as well as draw boxes/text/etc right there on the screen.
Usb2Kbd is hardware input emulator. It has been supported by EyeAuras since ~2021.
Now you can create your own for approximately 5$
- the only thing that is needed is small device from AliExpress/Amazon.
Here is the detailed step-by-step guide (russian / english).
I've also improved technical part and reworked settings window for better user experience.
Started working on native integration with ImGui - this is alternative approach to script/UI creation in EyeAuras. This should be the simplest one for those who only recently started coding - yes, some boilerplate code is requires to get things started, but after that it is very easy to understand. And ChatGPT can greatly help you.
Finally, it is possible to create truly 1-script mini-apps that incapsulate both UI and automation logic.
ReadManaged<T>
which is slower than Read<T>
, but respects MarshalAs
and managed structuresEyeAuras uses LeechCore, which is a fantastic library developed by Ulf Frisk, to integrate with DMA-devices out there. De-facto, LeechCore is a standard with which most devices out there are compatible.
For now, that integration is still in alpha-stage, drop me a message if you want to help with testing and are interested in developing something. Realistically, development using FPGA-board does not differ in any way from using ReadProcessMemory - EyeAuras abstracts you from all the complexities of managing LC API, reconnects, error handling, etc. All you have to focus on is writing a code.
Added more info here
Made it so only a subset of all Triggers is not available for selection as Enabling Conditions. Yes, that removes some flexibility from the system, e.g. you no longer can use Image analysis triggers. But. This also makes the system a bit simpler to understand, especially for new users.
Enabling conditions always meant to be global On/Off switches. If you want something more dynamic - use Trees/Macros or Auras with Triggers in them.
I continue to rework existing EA components 1-by-1 to leverage new UI framework capabilities. Newer version of folder properties editor not only loads faster, but is also more flexible.
Legacy version
New version.
For the first revision I just wanted to reach feature-parity with existing functionality.
Made it so you can set Target Window/Input Simulator for each tree/macro separately. Keep in mind that they also respect the normal properties hierarchy.
E.g. if you set Target Window
on a folder, in which Tree is located, it will respect that. But will also allow you to override that by setting another value on the tree itself.