New Node - Pixel Search - Early prototype

Let's welcome a new node which is accessible in Macros and BTs. It is the first one in the batch of nodes coming soon, nodes, focusing on computer-vision. Those nodes will be a direct replacement of triggers, which you're currently using in Auras. Migration process will take a lot of time and probably new Nodes will reach feature parity with corresponding Triggers only months from now, but eventually we'll get there.

Note, that Nodes DO NOT tick on their own. Image capture and analysis happens exactly at the same moment when the node gets executed.

Performance

Initially, performance of nodes could be worse than those that we had in Triggers - this is due to new mechanisms which were implemented for Computer Vision API which powers those new nodes.

Clicking on found Images/Pixels in Macros and Behavior Trees

New Nodes will be writing their results to Variables which are available via Bindings. For now, there is a single variable CvLastFoundRegion which will contain the last found region. This could be coordinates of a found pixel. Or coordinates of found image. Or ML class.

MouseMove Node

In MouseMove, there is now a new button, which allows to very quickly and easily use that variable as a source of coordinates.

Just click on the button, and, when executed, MouseMove will try to read coordinates from that variable.

Bugfixes/Improvements

• [BT] Added new button which allows to run BT/node until stopped
• [TextSearch] Fixed a problem in TextSearch - IncludeTextSegments was not saved into config

Computer Vision API improvements - Caching

Implementing a first prototype of the system which should allow to use CV API in BTs and Macros. The general idea is that now those methods which you call, be it ImageSearch/ColorSearch/etc, will cache underlying capture/processing mechanisms, which should make consequent similar calls from other parts of the program be much-much cheaper. We're talking seconds VS milliseconds here.

The mechanism tries to track which parts of the program use different parts of CV API and cache them accordingly. Monitor memory usage! Usually such systems tend to memory leak. A lot. Especially until properly tuned.

This API by itself is still very rough on edges and will be improved in upcoming releases.

WithoutCaching()

This method is now part of Computer Vision API and allows to entirely bypass caching mechanism if you do not need it - e.g. your entire program is a single C# script. In that case it does not make sense to rely on EA caching mechanisms and pay extra (yet small) price for it

Bugfixes/Improvements

• [Crash] Fixed crash which happened in BTs after latest changes ("Already cancelled")
• [Macros] Improved responsiveness of drag'n'drop in the tree
• [Scripting] Added Clear() method to MiniProfiler
• [Scripting] Optimized memory use a bit (AuraScript disposal)
• [Scripting] In auras, fixed a bug which could've prevented Script execution if aura was deactivated too quickly

Macros changes - disabled BT nodes in Macros for a while

in the latest version I've enabled nodes such as Cooldown/Selector/Sequence for use in Macros as well. The assumption was that it will allow to create rotations a bit easier and bring in BT-goodies to Macros as well. First testing has shown, that this functionality still needs more time in the oven as it raises too many questions, especially around drag'n'drop functionality.

I've disabled those nodes for now and they will become available later, as soon as UX around them will be ready.

Bugfixes/Improvements

• [Macros] Improved responsiveness of drag'n'drop in the tree

Major Macros Changes

The macro system has received significant upgrades, expanding both its functionality and the number of supported operations. In practice, behavior trees have proven to be fairly complex to grasp, while Macros were always meant to occupy the niche between very simple auras and more sophisticated behavior trees. These changes aim not only to reinforce that position but also to incorporate many of the strengths from both Auras and Trees.

Let’s dive in:

OnEnter / WhileActive / OnExit

This is the core concept from the Auras system. When something happens, a trigger fires. Then, in the aura, the following blocks are called sequentially:

• OnEnter – called immediately when the trigger activates.
• WhileActive – called repeatedly while the trigger remains active.
• OnExit – called once, the moment the trigger deactivates.

This combination of blocks can describe many situations and automate gameplay. However, it often lacked flexibility — for example, it wasn’t possible to add additional conditions within blocks or repeat actions multiple times. Auras simply weren’t designed for that, but these features are fundamental to Macros.

The one thing Macros were missing was the ability to check their own current state — to know whether they should be active at a given moment.

New Operation – CheckIsActive

This is where the new node CheckIsActive comes in. Its sole purpose is to let the macro body check if the macro is currently active. Just this node alone allows Macros to replicate the exact logic that Auras used for years.

There are many possible ways this kind of macro could look. Here’s just one example:

The idea is simple:

• Block one (OnEnter) runs on entry.
• Block two (WhileActive) is actually a Repeat loop that runs every 250ms as long as the macro remains active.
• When the macro deactivates, the loop stops, and the third block (OnExit) takes over to handle any exit logic.

In the near future, additional improvements will make creating "Aura-like" macros even easier.

Here’s another example – a macro that waits for deactivation and performs an action only on exit. This mirrors the behavior of an aura with just OnExit.

Porting Nodes from Behavior Trees

A whole set of nodes previously exclusive to Behavior Trees is now supported in Macros as well:

• Selector
• Sequence
• Cooldown
• Force Failure
• Force Success
• Inverter

Note: The first three nodes (Selector/Sequence/Cooldown) are most useful inside a Repeat block — that’s where they shine.

Example: Rotation with Macros

Let’s build a simple rotation with two skills and a basic attack, using macros:

Nothing too special — we check cooldowns, then availability, then cast in order. If skills are unavailable, we fall back to a basic attack.

Now here’s the exact same logic, wrapped inside a macro:

The logic is nearly identical, except now we're building the rotation inside the macro itself with a loop, and using a Selector to control flow.

Side note: Looking at this screenshot, it seems like I went a bit overboard with icons and formatting — it’s a bit too "noisy". I’ll try to clean that up.

Finally — in the foreseeable future, macros will also be editable in a graph view. This feature is still in development, but many users may find it easier to understand and work with macros this way.

Bugfixes / Improvements

• [BTs] Macros should now correctly stop when the main program window becomes active.

C# Scripting - Keybinds prototype

New instrument which allows to initialize hotkeys right from scripts.

[Keybind("p")] // Simple example - triggers when 'p' is pressed
[Keybind("Ctrl+2")] // Triggers only when 'Ctrl + 2' is pressed
[Keybind("Ctrl+2", IgnoreModifiers = true)] // Triggers on ANY combination containing 'Ctrl + 2' (e.g., 'Ctrl + Alt + 2')
public void OnKey(){
    Log.Info("Key pressed");
}

[Keybind(Hotkey = "4", SuppressKey = false)] // Handles the key, but it will still pass through to other apps
public void HandleKeyWithInjectedServices(IAuraEventLoggingService loggingService){
    Log.Info("Key pressed");
    loggingService.LogMessage(new AuraEvent(){ Text = "Message", Loglevel = FluentLogLevel.Info });
}

C# Scripting - Dependency Injection improvements

If you're using GetService somewhere in the code - you're already using DI system in EyeAuras. I've made some improvements in that part which should simplify the scripts

Here is how exactly same script looks like in 3 different forms:

Current approach - get APIs via GetService

var sendInput = GetService<ISendInputScriptingApi>();
sendInput.MouseMoveTo(200, 100); // Moves the mouse to X200 Y100
sendInput.MouseRightClick(); // Performs a right mouse click

Now two new approaches which you could(and should!) start using in your scripts. I am thinking about automatically injecting current APIs (such as SendInput) into your scripts - this would simplify and generalize the code. E.g. for ISendInputScriptingApi the name would be SendInput (like in example below), for IPlaySoundScriptingApi - PlaySound, for ComputerVision that could be something like IComputerVisionExperimentalScriptingApi Cv { get; init; } I will publish this as a separate update.

ISendInputScriptingApi SendInput { get; init; } // Automatically initialized when the script starts

SendInput.MouseMoveTo(200, 100); // Moves the mouse to X200 Y100
SendInput.MouseRightClick(); // Performs a right mouse click

Now

[Dependency] ISendInputScriptingApi SendInput { get; set; }

SendInput.MouseMoveTo(200, 100); // Moves the mouse to X200 Y100
SendInput.MouseRightClick(); // Performs a right mouse click

Bugfixes/Improvements

• [Scripting] Improved performance of scripts first start a bit (3-5%)

Computer Vision API prototype

This is kinda huge. Implemented new experimental scripting API, which allows to work with EyeAuras Computer Vision without using Auras at all. All you have to do is write a few lines of code and all the tools built throughout the years are right at your disposal - image search, color search, neural networks, etc.

Note that this API is straight out of oven and is subject to change, not even mentioning bugs and problems - please send your reports

Getting started

This is how your work with that new API could look like. For starters, lets find and image which is somewhere on the screen.

var cv = GetService<IComputerVisionExperimentalScriptingApi>()
    .ForScreen() //search through entire screen, could be ForWindow - see below
    .EnableOsd(fps: 10); //optional, with enabled on-screen-display refreshed @ 10 fps

var position = cv.ImageSearch(targetImagePath);
if (position.IsEmpty)
{
    Log.Info($"Found @ {position}");
} else {
    Log.Info($"Image not found");
}

That is it - no auras, no triggers, no actions. Everything is right there in these few lines of code. Under the hood, EA will try to optimize all your calls as much as possible, e.g. cache images, cache models, pre-load everything, etc. There is a lot of performance optimization work yet to be done in that area, but even the current state should be more than enough for most tasks.

Features

Here is what we get from the get go:

• supports loading images/models from local file system or URLs.
• PixelSearch - could be used to either find the pixel of specific color/shade OR check whether pixel at a specific location matches expected color
• ImageSearch - finds the image, plain and simple
• TextSearch - recognizes text in a specified region of the screen/window. Currently not very customizable, will be extended in the nearest future
• MLSearch - gets predictions from ML model - this call is mostly equivalent of the old Refresh()
• OnScreenDisplay (OSD) - if enabled, will visualize each and every call to this API right on your screen. You can also set FPS of that OSD to lower the load on the system, 5-10 is more than enough to see what is going on under the hood
• A LOT of new tools which will help you with usage of this API - window/region/point/color selectors, more on them below

Potential applications

• more granular control over EA - you can control each and every CPU tick spent on computer vision
• using Computer Vision straight from Macros/BTs. Soon we'll get Nodes that will be using that same API and will allow to avoid using AuraIsActive everywhere
• small portable scripts that could be shared via forum - easier to understand what is happening when you do not have to go through multiple auras

Planned enhancements - only after current version stabilizes

• making that API respect Bindings - that would allow to easier integrate APIs into trees and Macros
• allow to "peek" into Triggers which are under the hood of that API - just like you can Preview these triggers in Auras
• editor improvements - pre-load images (preview right in the editor) and better autocompletion in that part
• loading embedded files - you put models/images right into the script and load them on-demand

Example of Aim bot using image search

This is an example of a bot which tracks and clicks on image (using AimTrainer) Things to note on OSD:

• blue blinking rectangle - captured window
• (optional) large yellow rectangle - captured area inside that window
• small rectangle - successfull image match p.s. I've slowed everything down to get more meaningful demonstration, if tuned properly, the script can achieve up to 60-80 hits/second :D

//this is an example of a script
//which uses image search to find and follow a specific image inside a window
//It uses 2-times probing for optimization - if we know the previous location of the image
//it makes sense to repeat the search in that specific region first

//picking a window
var windowSelector = GetService<IWindowSelector>();
windowSelector.TargetWindow = "Aim Trainer";
var targetWindow = windowSelector.ActiveWindow ?? throw new InvalidOperationException("Window not found");

//this API is used to do Computer Vision stuff (image/text/color/ml search)
var cv = GetService<IComputerVisionExperimentalScriptingApi>()
    .ForWindow(targetWindow)  //for a specific window
    .EnableOsd(fps: 10); //with enabled on-screen-display refreshed @ 10 fps

//this API is used to generate mouse movements
var sendInput = GetService<ISendInputScriptingApi>();
sendInput.TargetWindow = targetWindow; //for a specific window

//could be either local file or URL
var targetImagePath = @"C:\Users\Xab3r\Documents\ShareX\Screenshots\2025-03\uupb4m3RQkfHa8sv.png";

//repeat until script is stopped
while (true)
{
	  //try to find the image
    var position = cv.ImageSearch(targetImagePath); 
    if (position.IsEmpty)
    {
        //not found
        continue;
    }

    Log.Info($"Found @ {position}");
    
    //found the image - moving the mouse to the center and clicking on object
    sendInput.MouseMoveTo(position.Center());
    sendInput.MouseClick();
}

or, alternatively, this is how the same loop could look like using neural network. ML is expected to be used by more experienced users, currently the method returns raw result in a form of WindowImageProcessedEventArgs - it provides maximum possible amount of control over extracted data

//as with the image, model path could be local or could point to remote file
var mlModelPath = @"https://s3.eyeauras.net/media/2025/03/AimLab_20240213193604OOBfW2f00U5K.onnx";
while (true)
{
    //get predictions from the model
    var result = cv.MLSearchRaw(mlModelPath); 
    if (!result.Detected.Predictions.Any())
    {
        //not found
        continue;
    }

    var currentPosition = result //WindowImageProcessedEventArgs
      .Detected //get detection results 
    	.Predictions //get predictions
    	.First() //more specifically, first one
      .Rectangle //get bounding box of that prediction IN LOCAL(aka World) coordinates
      .Transform(result.ViewportTransforms.WorldToWindow); //transform World coordinates to Window coordinates
    Log.Info($"Found via ML @ {currentPosition}");

    if (!currentPosition.IsEmpty)
    {
        //found the image - moving the mouse to the center
        sendInput.MouseMoveTo(currentPosition.ToWinRectangle().Center());
        sendInput.MouseClick();
    }
}

New coding tools

Alongside the new api, we needed more convenient tools which would allow to work with it. The main idea of those is that you use them to get some values which could then be inserted into the code, be it coordinates, color, window title or process name. This should greatly speedup process of development, especially for smaller scripts.

The list includes:

• Color selector - allows to select a color

var pixelLocation = cv.PixelSearch(Color.FromArgb(26, 26, 26)); //<- Color.FromArgb(26, 26, 26) inserted by Color selector

• Window Selector - allows you to pick a window and inserts the appropriate Window Match Expression - window title, process name, etc

var cv = GetService<IComputerVisionExperimentalScriptingApi>().ForWindow("l2.bin"); //<- "l2.bin" inserted by Process selector

• Region selector - allows to pick region of window/screen

cv.MLSearchRaw(mlModelPath, new Rectangle(719, 406, 988, 584)); //<- new Rectangle(719, 406, 988, 584) inserted by Region selector

• Point selector - allows to pick a specific point of window/screen

sendInput.MouseMoveTo(new Point(190, 393)); //<- new Point(190, 393) inserted by Point selector

Absolute/Relative coordinates

When you work with coordinates, do not forget that those could be either absolute(screen) or relative(window). Depending on use-case, one or another could be preferential. New tools support both - there are 2 different kinds of instruments, use at your own discretion.

Bugfixes/Improvements

• [Scripting] SendInput API is promoted from SendInputUnstableScriptingApi to SendInputScriptingApi - there were no changes for almost a year, looks stable enough
• [Scripting] Error line numbers should now be properly highlighted/displayed in case of compilation errors
• [Scripting] Added implicit conversion from string to WindowMatchExpression
• [Scripting] Added new struct Percentage which could be used to denote that the value is in % (e.g. 0.1 = 10%)
• [Scripting] All OSD objects now have Opacity
• [Scripting] Added WorldToWindow transformation matrix to WindowImageProcessedEventArgs - this allows to very easily calculate in-window coordinates after Refresh()
• [ColorSearch] Minor optimization - should be less memory-hungry and work a bit (~2-3%) faster
• [OSD] Fixed a bug with OSD Rectangles coloring - R and G color channels were swapped

Bugfixes/Improvements

• [UI] Fixed a nasty problem with authentication - in some cases even pack authors were not able to push the update aka "Non-authorized users are not allowed to update shares"

Performance optimizations - ALPHA

Major changes in how EyeAuras manages memory for the images. May make things better, may break everything - we'll see.

ML Search Trigger - Added default models download

For a demonstration purposes and for some quick testing, added selector which allows you to download one of well-known Yolo models, including those which feature Segmentation and Classification. Selector is available only when model is NOT loaded.

E.g. here are results of Yolo 8 Small - Segmentation

and here are results of the latest Yolo 12 Turbo - Small - notice that even Turbo version nowadays not only yields more reliable results, but it also is able to detect more objects(person in the car) on the scene. Thank you, progress :)

ML Search Trigger - Changed Resize Method - Breaking change

When you're using ML model, it usually has hard-coded resolution, e.g. 640x640. When ML model gets fed with an Image, that image must be resized to accomodate model's resolution - there is no other way around it. Depending on how the training process is done, usually it is either Letterboxing (adding black bars without changing aspect ration) or Stretching.

Previously, EyeAuras was trying to "guess" the best method depending on model type and version, but this introduced more confusion than helped.

That is why, from now on, default resize method is Stretching and if you want to change that - just throw in Resize effect and pick whichever method fits your model best.

1. Open Effects window

2. Added Resize Effect and setup it accordingly to your model resolution/type

Bugfixes/Improvements

• [Capture] Fixed a problem with region-selection in Preview window when Resize/Rescale effects were applied

Packing - Distribution Policy

Added new option, which intends to do two things:

1) Try to lower entry bar for new users Practice has shown, that many new users, given link to pack's page, instead of downloading the pack, which would contain compatible version of EyeAuras and scripts, choose to download standalone version and Import pack manually. This could lead to a lot of problems, such as:

• pack could be published using Alpha version and user downloaded Stable - most of the time Stable is not compatible as it is older and has less functionality
• when importing multiple Packs into the same EA, it is very easy to go over Free tier limit of 10 auras. Packs help to avoid that - you can have as many Free-tier packs as you want running simultaneously. I do not want to force people into buying the subscription that way - it is intended that Pro tier is only for complex packs of auras
• by importing the pack manually, users usually do not use Subscriptions/Synchronization mechanism which can provide description of the pack/track pack updates and simplify the process of working with the pack in general. Packs solve that by having Synchronization set from the very beginning

2) Simplify packs support for authors If authors are 100% sure, that users are using a specific portable version of EA, it makes things easier for them to debug and troubleshoot. This should make things more supportable long-term.

Pack Distribution Policy

• Any -> If set, users can either Import the script or Download Pack
• Prefer Packed - If set, users can either Import the script or Download Pack, but there will be focus on downloading packed version
• Packed Only - If set, users can Download Pack, but Import in any form is not allowed

Packing - authors-only - editing options on the website is disabled

There is no loss of functionality, everything is still editable via EyeAuras UI

Previously, it was possible to edit Packaging option on both EA desktop app and on the website as well (application name, config options, etc). I am changing how the packaging works in general and to make things more stable, I've disabled editing pack options on the website.

This may come back in the future, but for now, the primary way of editing Packaging Options is via EyeAuras UI

Bugfixes/Improvements

• [Web] Fixed links on Aura Library page - they were missing hostname

C# Scripting - Script File Provider

This is a new functionality in scripting subsystem which allows you to embed custom files right into EyeAuras - CSS/JS/Markdown/etc.

This will allow you to use custom JS/CSS in your BlazorWindows, some configuration/data files, bring up custom DLLs, etc.

Here is an example: https://wiki.eyeauras.net/en/scripting/examples/basic/file-provider

(README.md is a custom file added to the script)

//built-in FileProvider which allows to access script environment files
var fileProvider = GetService<EyeAuras.Repl.IScriptFileProvider>();

var files = fileProvider.GetDirectoryContents("/");
Log.Info($"Script files:\n\t{files.DumpToTable()}");

var readmeContent = fileProvider.ReadAllText("README.md"); //or fileProvider.GetFileInfo() to get access to raw data
Log.Info($"README:\n{readmeContent}");

For the next few weeks only subset of all file types will be supported. As soon as I'll be sure that the system works, support will be extended and any arbitrary file could be embedded into your script and will be available to use right from your code.

Bugfixes/Improvements

• [UI] Fixed a problem with pre-compiled Packs - Overlays were not working properly