This release improves developer experience by updating the feedback UI when using some of our added features from recent releases. We’ve also updated our options dialog’s look and feel alongside some of line highlighting options. We’ve also fixed many of the bugs and issues based on user reports.

The highlight of this release is a new option when using VA’s extract method so you can now fine-tune the parameter list—which includes selecting variables, excluding unnecessary ones, or arranging their order. 

On the visual feedback side, we’ve enhanced the popup interface when using Replace Auto With Exact Type. Additionally, macros expansion will also have its context revealed upon hovering. Learn more about these changes by going through our release blog post.

Download the release now by visiting our website download page.

Enhanced Extract Method with parameter customization

Visual Assist’s Extract Method feature now offers full parameter customization through an intuitive dialog interface. When extracting code into a new method, developers can now:

• Add, remove, or reorder parameters before the method is created
• Modify function signatures using natural coding language syntax
• Make extracted methods more general by adding custom parameters

This enhancement skips most of the post-extract method editing, instead, a smarter interface guides you to adjust the extracted method as Visual Assist creates the implementation.

This is unlike most rigid UI implementations found in other tools. Visual Assist uses its intelligent parsing to understand your code modifications, providing a more natural and flexible experience.

New editing options for extract method. Edit name, move, or reorder parameters.

How it works: Select code you want to extract, choose Extract Method under the quick actions menu, and customize the function declaration in the dialog using standard C++ syntax. Use VA’s updated UI to create the optimized method accordingly.

Macro Expansions on Hover (Quick Info)

This was added based on a request from a user who was developing in Unreal Engine (UE) in Visual Studio. Many UE users turn off the built-in IntelliSense and just rely solely on VA’s features in order to maximize performance on large codebases—which is usually associated with the size of Unreal projects. Unfortunately, this also means that the macro expansion info provided by IntelliSense is also removed.

With this new change, however, VA can now display macro expansions instantly when you hover over macro definitions, providing immediate insight into complex preprocessor directives without interrupting your workflow.

Hover over macro definitions to show its expansion instantly.

Improved dot to arrow conversion now supports for auto pointers

VA’s dot-to-arrow conversion automatically changes . to -> when accessing members through pointers, eliminating the need to manually switch between dot and arrow operators.

With this update, however, the dot to arrow conversion feature now handle auto pointer declarations better. The plugin now recognizes explicit pointer hints in auto variable declarations, providing more accurate code completion and conversion.
Example:

int myInt = 1;
int* myIntPtr = &myInt;

auto myAutoPtr = &myInt;      // Implicit pointer
auto* myExplicitAutoPtr = &myInt;  // Explicit pointer - now detected!

In the above example, “myAutoPtr” and “myExplicitAutoPtr” variables have their auto type both resolved to “int *”, but with the second one the fact that it should be a pointer is made explicit.

This enhancement makes the feature more reliable when working with modern C++ auto declarations, reducing coding errors and improving developer productivity.

Modernized Options Dialog Interface

The Visual Assist Options dialog has been completely rebuilt with a modern UI framework, moving away from the legacy Win32 interface theme. This modernization represents the first step in a comprehensive UI refresh that will extend to other Visual Assist components in future releases.

Visual Assist 2025.3 updates the look and feel of the options dialog.

Improved Ray Line Highlighting Style

One of VA’s ways to showcase the current active line is achieved by using the “ray lines” highlighting style. Ray lines provide a subtle, non-intrusive way to highlight the current line using minimal horizontal lines without left/right borders.

New improved ray line highlighting style.

This option has been refined with better vertical spacing, addressing user feedback about the previous tight layout.

If you prefer using a different highlighting style, you can choose from the available options in the options dialog (Thin Frame, Background Color and Ray Lines). To choose your preferred highlighting style, navigate to Extensions — VAssistX —Visual Assist Options — Editor — Highlighting —”Highlight current line with:” 

Enhanced Replace Auto With Exact Type Accessibility

Building on the popular Replace Auto With Exact Type feature in previous releases, Visual Assist now makes this functionality more accessible via the right click menu or automatically via typing  the auto keyword.

Use Quick Info menu or right click on Auto.

Bug Fixes

For bug fixes and general improvements, the most critical update is the restoration of shader syntax coloring support in Visual Studio 17.12.0 and newer versions, addressing multiple related issues with code formatting and syntax highlighting in shader files across VS 2019 and 2022.

Additionally, there are significant performance improvements for Unreal Engine projects, specifically enhanced responsiveness of quick actions and refactoring menus. The release also includes fixes for HLSL file formatting and improved navigation performance for MAUI base classes.

The following list summarizes the most important bugs addressed in this release:

• Fix for code formatting not working in shader files in VS 2019+
• Fix for syntax coloring not working in shader files in VS 2022
• Restored shader syntax coloring support in Visual Studio 17.12.0 and newer
• Improved responsiveness of quick actions and refactoring menu in Unreal Engine projects
• Fixed inconsistent filter control display in initial Find References results
• Improved performance when navigating from MAUI base classes using Go To Related
• Resolved formatting issues in HLSL files when shader support is enabled in Visual Studio 2019 and 2022

Availability & Feedback

This release was made generally available on June 30th and can be downloaded via the downloads page. As always, we appreciate feedback, especially on recently introduced features and the UI changes we introduced. 

Update now to an active license to utilize all the features and fixes in this release. And if you have any questions or encounter any issues, feel free to reach out to support@ewholetomato.com.

The post Visual Assist 2025.3 release post first appeared on Tomato Soup.

From those conversations, one thing is clear: despite the rise of new alternatives and lively debates about its future, C++ is and will remain a cornerstone across industries for years to come. We’re proud that Visual Assist has served the MSVS/C++ community for decades, and we sincerely hope to serve you for decades more.

Of course, the landscape is shifting. The gaming industry is facing significant headwinds following massive post-Covid growth and investment. Companies are still navigating how to integrate formerly nascent AI products that are rapidly becoming a mainstay for many coders. And debates about C++ safety continue to heat up.

From my perspective, this is why it’s so important that we remain connected to the community we serve. As our tech progresses, old problems become obsolete, and new problems arise. I’m proud of the work our team has done – and continues to do – to first listen to our customers, and, secondly, act thoughtfully to build solutions that solve them.

One focus that will never fade for us is user experience. Developers consistently tell us they expect tools that are polished, seamless, and smart…tools that don’t fight for attention when not warranted or beg for a prompt, but instead subtly offer productivity boosts at the right time, without breaking concentration. 

That’s why our roadmap for the coming months specifically focuses on honing VA’s existing capabilities to deliver even more productivity. This starts with a modernization of our UI (stay tuned for our next update), better surfacing of and eventually something we’re very excited about: subtle, behind-the-scenes Ai features. In other words, not another bolted-on AI chatbot, but  “under the hood” integrations that make the things you love about VA even better – something that over 70% of you responded favorably to in our recent community survey.

For example, can our parser coupled with AI quickly generate accurate unit tests? Can we leverage AI to identify memory safety issues, then use VA’s refactoring to address them? How can AI improve our renames, inspections, and navigation? These are the questions we’re asking. Of course it’s early, and there’s much work to be done, but we’re excited about the possibilities. And you should be too!

By the way, do you have thoughts? Send me a note – I’d love to hear what’s on your mind.

Ben Schwenk,
Whole Tomato general manager

The post Where to next? A quick update about Visual Assist’s future from our GM first appeared on Tomato Soup.

Many developers accept these issues as just part of the job. But what if they didn’t have to be?

Visual Assist, a powerful productivity extension for Visual Studio, was built to solve the exact problems that slow developers down, without changing your entire workflow. In fact, you might already be struggling with features that have smarter, faster alternatives within reach.

In this article, we’ll explore how Visual Assist can help you improve Visual Studio performance, uncover better ways to navigate large projects, and fix annoying quirks like IntelliSense not working, especially if you’re working with Unreal Engine or C++. Whether you’re dealing with slow Visual Studio response times or you’re simply unaware of better options, this guide will show you how to reclaim your flow and speed things up.

Let’s take a closer look at the Visual Assist features that can fix what’s slowing you down.

Common Visual Studio pain points (and how Visual Assist fixes them)

In this section, we’ll explore common Visual Studio performance issues that most developers face—and how Visual Assist provides effective solutions.

Problem #1: Clunky file navigation in large projects

The problem
Working with large codebases in Visual Studio often means dealing with hundreds—or even thousands—of files spread across multiple folders. While Visual Studio’s native file explorer gets the job done, it can feel painfully sluggish when navigating complex projects. Endless scrolling and limited filtering options disrupt your focus and waste precious time.

The fix
Visual Assist’s Open File in Solution feature offers a faster, smarter alternative. Designed for performance, it allows you to locate any file instantly, even in massive solutions, using just a few keystrokes. The built-in filtering engine narrows down your results as you type, letting you jump to exactly what you need without wading through the entire project tree.

Visual Assist offers a suite of powerful navigation tools specifically designed for large solutions. These tools let you jump between files, symbols, methods, and related code with incredible speed and accuracy:

• Open File in Solution: Quickly find and open any file with just a few keystrokes. It supports filtering, wildcards, and even fuzzy search. Explore more about Open File in Solution.

Accessing the Open File in Solution feature via the VAssistX menu in Visual Studio

Visual Assist – Open File in Solution Example

• Find Symbol in Solution: Search for any class, method, or variable—even if you only remember part of the name. We will discuss more about this feature in the next section.
• Goto Related: Instantly jump between related files, like header/implementation pairs or base/derived classes. Read more on the Goto Related feature.

Go to Related feature in Visual Assist

Go to Members of the Class User

Members of the Class User

• List Methods in Current File: Navigate large files by jumping to any method or function in a dropdown list.

These features eliminate the need to scroll endlessly or manually search through your folder structure. Whether you’re working in C++, C#, or Unreal Engine code, Visual Assist helps you move through your project like a pro.

Bonus tip
Want to locate a file or symbol without knowing the exact name? Just use an asterisk * in your search. For example, typing *Manager in Open File in Solution or Find Symbol will return results like UserManager, AccountManager, and more. Fuzzy search makes finding things faster—even when your memory isn’t perfect.

Problem #2: Can’t recall the exact name of a symbol

The Problem
You’re in the zone, deep into a feature or bug fix, and you need to find a class, method, or file—but you can’t remember the exact name. Visual Studio’s default search isn’t forgiving. If your input isn’t precise, you’re met with zero results or a long list of unrelated suggestions, forcing you to waste time browsing through files manually.

The Fix
Visual Assist makes this easier with fuzzy search built into tools like Open File in Solution and Find Symbol. These features allow you to search using partial names or approximate guesses. Can’t remember if it was UserManager or AccountManager? Just type *manager, and Visual Assist will surface relevant results instantly—even if your memory is fuzzy.

Using the Find Symbol feature in Visual Assist to locate symbols quickly

Visual Assist Find Symbol example

Bonus Tip
Combine fuzzy search with filters to narrow down by file type, scope, or symbol kind. Want even more control? Use negative filters by adding -word to your search. For example, *Manager -Account shows all items with “Manager” but excludes any that include “Account”. It’s one of the fastest ways to find exactly what you need, especially in large or unfamiliar codebases.

Problem #3: Unreal Engine source code shows incorrect red squiggles

The Problem
If you’re developing with Unreal Engine in Visual Studio, you’ve probably run into frustrating red squiggles under perfectly valid code. This usually isn’t your fault—it’s IntelliSense struggling to interpret Unreal Engine’s complex macro system. These false errors clutter your editor, create confusion, and slow down your workflow.

The Fix
Visual Assist comes with dedicated Unreal Engine support that understands UE’s syntax, reflection macros, and naming conventions far better than default IntelliSense. It correctly parses Unreal code, eliminating misleading squiggles and giving you accurate suggestions. In fact, many developers choose to disable IntelliSense entirely and rely solely on Visual Assist for parsing, symbol lookup, and navigation, resulting in cleaner code views and faster performance.

Bonus Tip
You can disable IntelliSense in Visual Studio’s settings and still enjoy full code completion, navigation, and error-free parsing through Visual Assist—especially helpful when working on large UE4 or UE5 projects.

Visual Assist for Unreal Engine

Problem #4: Visual Studio lags when typing or scrolling

The Problem

When working on extensive projects, many developers experience lag in Visual Studio, particularly while typing or scrolling. This slowdown is often reported when IntelliSense is enabled, especially in large or complex codebases. Developers have observed that background parsing and real-time suggestions can affect responsiveness and break focus. In Unreal Engine projects, for example, IntelliSense may even become unresponsive, prompting many to disable it in favor of more reliable alternatives like Visual Assist.

The Fix

Visual Assist is built for speed. The parsing engine of Visual Assist operates more efficiently than IntelliSense, particularly when working with large or complex projects. The combination of disabling IntelliSense with Visual Assist’s code suggestions, navigation tools, and context-aware features will eliminate performance delays, allowing you to continue coding without interruptions.

Bonus Tip

The performance of developers improves right away when they disable IntelliSense completely and let Visual Assist handle code completion, reference finding, and symbol navigation tasks.

How to Enable Visual Assist’s Code Suggestions

Open Visual Studio.

Go to the Extensions menu ? VAssistX ? Visual Assist Options.

In the Visual Assist Options window, navigate to Suggestions.

Here you can enable the required options.

Click OK to apply the settings.

Optional: Disable IntelliSense (for best performance)

To rely only on Visual Assist and reduce lag:

• Go to Tools ? Options ? Text Editor ? C/C++ ? Advanced

Set Disable IntelliSense to True

This allows Visual Assist to fully handle code completion, navigation, and suggestions, resulting in a smoother experience, especially in large projects or when working with Unreal Engine.

Problem #5: Limited refactoring tools in Visual Studio

The Problem
While Visual Studio offers some built-in refactoring options, they often fall short, especially in complex C++ projects. Refactors like renaming symbols or introducing variables can be inconsistent, incomplete, or prone to errors depending on the context. This makes developers hesitant to trust these tools, slowing down their workflow.

The Fix
Visual Assist provides a robust and reliable set of refactoring tools designed with real-world C++ usage in mind. You get smart options like Rename, Encapsulate Field, Introduce Variable, Change Signature, and Create from Usage, all backed by deeper code understanding. These tools work more consistently and accurately across different project types and coding styles, helping you restructure code confidently and without breaking anything.

Bonus Tip

Visual Assist’s refactoring tools are not only more consistent—they’re also smarter. For example, they understand Unreal Engine macros like UFUNCTION and UPROPERTY, allowing you to safely rename or refactor even macro-decorated code that typically breaks under standard IntelliSense-based tools.

Create from Usage – Smart refactoring made easy

Try the Create from Usage feature when writing new code—it lets you generate declarations and implementations on the fly by referencing them before they exist. It’s a fast and intuitive way to build out logic without breaking your coding rhythm.

How to Use “Create from Usage” in Visual Assist

1. Just write your code as if the function, variable, or method already exists.

For example:

class MyClass {};

int main()
{
    MyClass obj;
    obj.DoSomethingUseful(); // <- Now Visual Assist can step in!
}

If DoSomethingUseful() hasn’t been declared or defined yet, Visual Assist will detect this.

2. Place your cursor on the symbol (e.g., method or variable) you just used.
3. Press Alt+Shift+Q (Visual Assist Quick Action menu)

Alternatively, right-click the symbol and look for Quick Actions and Refactorings ? Create from Usage.

Visual Assist will offer to generate the corresponding declaration and definition for you—automatically placing them in the appropriate header and source files if needed.

Declared method in MyClass

Tip:

This feature is especially useful when you’re doing test-driven development or writing out logic before formalizing structure. It keeps your flow uninterrupted by letting Visual Assist handle the boilerplate creation.

Conclusion

Visual Studio is a powerful IDE—but as your projects grow, so do the cracks in its default experience. From sluggish file navigation and limited refactoring tools to IntelliSense breakdowns in Unreal Engine projects, these friction points can quietly eat away at your productivity.

That’s where Visual Assist steps in.

Whether you’re building AAA games in Unreal Engine, managing sprawling C++ projects, or simply tired of lag and limitations, Visual Assist provides the tools to help you code faster, smarter, and more confidently. With features like fuzzy symbol search, advanced refactoring, code suggestions, and context-aware navigation, Visual Assist fills in the gaps and removes the roadblocks that slow you down.

Most importantly, it integrates seamlessly into your workflow—no steep learning curve, no drastic changes. Just better performance, deeper code understanding, and a smoother development experience.

If you’ve been struggling with Visual Studio performance, now you know: Visual Assist has the fix.

Download a free trial of Visual Assist and experience the difference for yourself.

The post Struggling with Visual Studio Performance? Visual Assist Has the Fix first appeared on Tomato Soup.

Download the release now from our website download page.

VA Integration modes: Updated First Run Dialog

In VA 2024.9, new integration modes were added to allow users to personalize their experience with how Visual Assist features were presented and accessed. You can visit the integration mode page to learn more about available integration modes. This dialog was initially shown for fresh installs only. 

VA 2025.1 makes the dialog appear for every user who has not previously encountered it, regardless of whether they are installing Visual Assist for the first time or have updated from an earlier version.

The first run dialog allows users to pick VA integration modes.

Option to exclude symbols in GoTo and List Methods navigation

This small tweak adds an option to skip selecting symbols after you navigate to it. In that way, you can immediately start typing before the symbol, or you would be able to keep your current selection even after jumping to different parts of the code.

This currently works for VA’s Go To and List Methods in Current File (Alt + M). Access the new option via the toolbar.

Open the options dialog to select symbol selection behavior.

Specify access level on Extract Method

VA introduces a new option that allows developers to specify the access level (public, private, or protected) directly when using the Extract Method refactoring tool.

Specify the visibility of methods obtained via Extract Methods using the new options.

This streamlines the refactoring process by providing an immediate choice of access level for the new method being created from the selected block of code. Previously, after extracting a method, the default access level was applied (usually private), and any changes to this required manual adjustment. 

With this update, developers can set the desired access level in the initial step of the extraction, ensuring better code organization and encapsulation from the outset.

New features added for C++ modules when importing

When declaring new modules into your project, VA will recognize what you are trying to do and core navigation and features will work accordingly. This includes autocompletion prompts, adding includes, finding references, and other pertinent navigations.

C++ modules were added in C++ 20 to help improve the compilation times and the overall build performance of C++ programs. Modules provided a modern alternative to traditional header files and includes by allowing programmers to define interfaces that are compiled separately and imported as needed. 

This reduces the need to include headers and recompile code unnecessarily, which can significantly speed up the build process. 

Modules in C++ are fairly new and the committee is still pushing for mass adoption. But whether you’re an early adopter of C++ modules or not, this VA update should help you find available modules should the need arise.

VA now parses C++ modules, enabling core navigations and features.

Support for *.IXX module files.

This change allows VA to parse and understand the new modular structure introduced with C++20. This means that developers can now work with module interface files (.ixx) directly within the Visual Assist environment, benefiting from features like syntax highlighting, code navigation, and intelligent code completion that were previously limited to traditional header and source files.

For instance, if you had symbols declared in an .IXX file, VA now properly parses them and navigation features such as Go To will now work properly.

Configurable snippet base for unit test generation

There are new configuration options available for Unit Test Generation that allow developers to customize the boilerplate code that is automatically generated when creating unit tests. 

The unit test generation feature was first introduced in VA 2024.9 and added a new feature to create a boilerplate that follows the Google Test framework. This creates a new test file, prepopulated with placeholders following the test structure to make it more convenient to users.

VA 2025.1 upgrades this new feature with the flexibility of specifying preferences and settings that align with their project’s requirements or personal coding standards.

New modernized tomato icon 

Our loveable tomato icon has been given a fresher look for the new development year! This was primarily done to improve user experience and accessibility. This change was made to increase contrast, and make VA’s features more distinguishable so users can utilize it more effectively in the IDE.

Updated tomato icon. Will be rolled out for every platform!

We’ve also taken the opportunity to maintain a consistent look and feel across all instances of our tomato icon. This update ensures that they appear correctly and uniformly across all platforms.

Excluding C# files from parsing via “settings.json” file.

VA 2025.1 builds upon a similar functionality introduced in VA 2022.4 where an option to consider configuration instructions outlined in a .json file can be used to skip unnecessary parsing when building solutions. 

This new feature does something similar, but for C# instead. The feature allows developers to specify which C# files should be excluded from parsing by Visual Assist through a configuration in a .json file.

This is particularly useful for developers working cross-platform as this tells Visual Studio and Visual Assist to “open a file but do not parse anything else apart from a specific part.” 

So even if users have dozens of non Visual Studio files in one directory, you can specify which files are part of the project you are trying to open. (Otherwise, VS and VA will try to parse the whole directory—very resource intensive and time consuming.)

Bug Fixes

For bug fixes and general improvements, most of them were based on user feedback and reports. The most notable of these updates are fixes for a crash happening when logging is enabled while debugging, and a hang involving the Go To features. There was also a pesky bug related to having two-monitor setups that is now fixed. 

The following list summarizes the most important bugs addressed in this release:

Fix for flashing in the Find References results window on start or when changing monitors.

• Fix for Encapsulate field in C#.
• Fix for VA Hashtags not being suggested.
• Fix for assignment suggestions not appearing in some cases.
• Fix for dialog hang that could sometimes happen when using Goto.
• Increased the display limit for Move Method to Base Class to 12 base classes (from 6).
• Fix for Move Method to Base Class sometimes not displaying the base class list to move to.
• Fix for tip of the day links opening in Internet Explorer rather than the default browser.
• Fix for a crash that could sometimes happen when troubleshoot logging is enabled.
• Fix for attributes displaying in a difficult to read color when in dark mode.

Availability & Feedback

This release was made generally available on March 28th and can be downloaded via the downloads page. As always, we appreciate feedback, especially on recently introduced features and the UI changes we introduced. Thank you for helping us create a better experience for all our users.

Update now to an active version to utilize all the features and fixes in this release. And if you have any questions or encounter any issues, feel free to reach out to support@ewholetomato.com.

The post Visual Assist 2025.1 release post first appeared on Tomato Soup.

Let’s dive in and explore how we can achieve this.

This is a blog post made in collaboration with Bartlomiej Filipek from C++ stories. You can visit his blog here.

The inspiration

The inspiration for this article came from a recent update for Visual Assist – a tool that heavily improves Visual Studio experience and productivity for C# and C++ developers.

In one of their blog post, they shared:

The initial parse is 10..15x faster!

What’s New in Visual Assist 2024—Featuring lightning fast parser performance [Webinar] – Tomato Soup

After watching the webinar, I noticed some details about efficiently getting file attributes and I decided to give it a try on my machine. In other words I tried to recreate their results.

Disclaimer: Idera, the company behind Visual Assist, helped me write this post and sponsored it.

Understanding File Attribute Retrieval Methods on Windows

On Windows, there are at least a few options to check for a file change:

• FindFirstFile[EX] – with Basic, Standard and LargeFetch options
• GetFileAttributesEx
• std::filesystem
• GetFileInformationByHandleEx

Below, you can see some primary usage of each approach:

FindFirstFileEx

FindFirstFileEx is a Windows API function that allows for efficient searching of directories. It retrieves information about files that match a specified file name pattern. The function can be used with different information levels, such as FindExInfoBasic and FindExInfoStandard, to control the amount of file information fetched.

WIN32_FIND_DATA findFileData;
HANDLE hFind = FindFirstFileEx((directory + "\\*").c_str(), FindExInfoBasic, &findFileData, FindExSearchNameMatch, NULL, 0);

if (hFind != INVALID_HANDLE_VALUE) {
    do {
        // Process file information
    } while (FindNextFile(hFind, &findFileData) != 0);
    FindClose(hFind);
}

Additionally you can also pass FIND_FIRST_EX_LARGE_FETCH as the additional flag to indicate that the function should use a larger buffer which might bring some extra performance.

GetFileAttributesEx

GetFileAttributesEx is another Windows API function that retrieves file attributes for a specified file or directory. Unlike FindFirstFileEx, which is used for searching and listing files, GetFileAttributesEx is typically used for retrieving attributes of a single file or directory.

WIN32_FILE_ATTRIBUTE_DATA fileAttributeData;
if (GetFileAttributesEx((directory + "\\" + fileName).c_str(), GetFileExInfoStandard, &fileAttributeData)) {
    // Process file attributes
}

GetFileInformationByHandleEx

GetFileInformationByHandleEx is a low level routine that might be tricky to use, but gives us more control over the iteration. The main idea is to get a lerge buffer of data and read it on the application side, rather than rely on sometimes costly kernel/system calls.

Assuming you have a file open, which is a directory, you can iterate over its children in the following way:

while (true) {
    if (!GetFileInformationByHandleEx(
        hDir,
        FileFullDirectoryInfo,
        pInfo,
        sizeof(buffer))) {
        DWORD error = GetLastError();
        if (error == ERROR_NO_MORE_FILES) {
            break;
        }
        else {
            std::wcerr << L"GetFileInformationByHandleEx failed (" << error << L")\n";
            break;
        }
    }

    do {
        if (!(pInfo->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
            FileInfo fileInfo;
            fileInfo.fileName = std::wstring(pInfo->FileName, pInfo->FileNameLength / sizeof(WCHAR));
            FILETIME ft{};
            ft.dwLowDateTime = pInfo->LastWriteTime.LowPart;
            ft.dwHighDateTime = pInfo->LastWriteTime.HighPart;
            fileInfo.lastWriteTime = ft;
            files.push_back(fileInfo);
        }
        pInfo = reinterpret_cast<FILE_FULL_DIR_INFO*>(
            reinterpret_cast<BYTE*>(pInfo) + pInfo->NextEntryOffset);
    } while (pInfo->NextEntryOffset != 0);
}

std::filesystem

Introduced in C++17, the std::filesystem library provides a modern and portable way to interact with the file system. It includes functions for file attribute retrieval, directory iteration, and other common file system operations.

for (const auto& entry : fs::directory_iterator(directory)) {
    if (entry.is_regular_file()) {
        // Process file attributes
        auto ftime = fs:last_write_time(entry);
        ...
    }
}

The Benchmark

To evaluate the performance of different file attribute retrieval methods, I developed a small benchmark. This application measures the time taken by each method to retrieve file attributes for N number of files in a specified directory.

Here’s a rough overview of the code:

The FileInfo struct stores the file name and last write time.

struct FileInfo {
    std::wstring fileName;
    std::variant<FILETIME, std::filesystem::file_time_type> lastWriteTime;
};

Each retrieval technique will have to go over a directory and build a vector of FileInfo objects.

BenchmarkFindFirstFileEx

void BenchmarkFindFirstFileEx(const std::string& directory, 	
                              std::vector<FileInfo>& files, 
                              FINDEX_INFO_LEVELS infoLevel) 
{
   WIN32_FIND_DATA findFileData;
   HANDLE hFind = FindFirstFileEx((directory + "\\*").c_str(),
                                   infoLevel, 
                                   &findFileData, 
                                   FindExSearchNameMatch, NULL, 0);

   if (hFind == INVALID_HANDLE_VALUE) {
       std::cerr << "FindFirstFileEx failed (" 
                 << GetLastError() << ")\n";
       return;
   }

   do {
       if (!(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
           FileInfo fileInfo;
           fileInfo.fileName = findFileData.cFileName;
           fileInfo.lastWriteTime = findFileData.ftLastWriteTime;
           files.push_back(fileInfo);
       }
   } while (FindNextFile(hFind, &findFileData) != 0);

   FindClose(hFind);
}

BenchmarkGetFileAttributesEx

void BenchmarkGetFileAttributesEx(const std::string& directory,
                                  std::vector<FileInfo>& files) 
{
   WIN32_FIND_DATA findFileData;
   HANDLE hFind = FindFirstFile((directory + "\\*").c_str(),
                                &findFileData);

   if (hFind == INVALID_HANDLE_VALUE) {
       std::cerr << "FindFirstFile failed (" 
                 << GetLastError() << ")\n";
       return;
   }

   do {
       if (!(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
           WIN32_FILE_ATTRIBUTE_DATA fileAttributeData;
           if (GetFileAttributesEx((directory + "\\" + findFileData.cFileName).c_str(), GetFileExInfoStandard, &fileAttributeData)) {
               FileInfo fileInfo;
               fileInfo.fileName = findFileData.cFileName;
               fileInfo.lastWriteTime = fileAttributeData.ftLastWriteTime;
               files.push_back(fileInfo);
           }
       }
   } while (FindNextFile(hFind, &findFileData) != 0);

   FindClose(hFind);
}

BenchmarkStdFilesystem

And the last one, the most portable technique:

void BenchmarkStdFilesystem(const std::string& directory, 
                            std::vector<FileInfo>& files) 
{
    for (const auto& entry : std::filesystem::directory_iterator(directory)) {
        if (entry.is_regular_file()) {
            FileInfo fileInfo;
            fileInfo.fileName = entry.path().filename().string();
            FILETIME ft{};
            ft.dwLowDateTime = pInfo->LastWriteTime.LowPart;
            ft.dwHighDateTime = pInfo->LastWriteTime.HighPart;
            fileInfo.lastWriteTime = ft;
            files.push_back(fileInfo);
        }
    }
}

BenchmarkGetFileInformationByHandleEx

void BenchmarkGetFileInformationByHandleEx(const std::wstring& directory, std::vector<FileInfo>& files) {
    HANDLE hDir = CreateFileW(
        directory.c_str(),
        GENERIC_READ,
        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
        NULL,
        OPEN_EXISTING,
        FILE_FLAG_BACKUP_SEMANTICS,
        NULL
    );

    if (hDir == INVALID_HANDLE_VALUE) {
        std::wcerr << L"CreateFile failed (" << GetLastError() << L")\n";
        return;
    }

    constexpr DWORD BufferSize = 64 * 1024;
    uint8_t buffer[BufferSize];
    FILE_FULL_DIR_INFO* pInfo = reinterpret_cast<FILE_FULL_DIR_INFO*>(buffer);

    while (true) {
        if (!GetFileInformationByHandleEx(
            hDir,
            FileFullDirectoryInfo,
            pInfo,
            sizeof(buffer))) {
            DWORD error = GetLastError();
            if (error == ERROR_NO_MORE_FILES) {
                break;
            }
            else {
                std::wcerr << L"GetFileInformationByHandleEx failed (" << error << L")\n";
                break;
            }
        }

        do {
            if (!(pInfo->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
                FileInfo fileInfo;
                fileInfo.fileName = std::wstring(pInfo->FileName, pInfo->FileNameLength / sizeof(WCHAR));
                FILETIME ft{};
                ft.dwLowDateTime = pInfo->LastWriteTime.LowPart;
                ft.dwHighDateTime = pInfo->LastWriteTime.HighPart;
                fileInfo.lastWriteTime = ft;
                files.push_back(fileInfo);
            }
            pInfo = reinterpret_cast<FILE_FULL_DIR_INFO*>(
                reinterpret_cast<BYTE*>(pInfo) + pInfo->NextEntryOffset);
        } while (pInfo->NextEntryOffset != 0);
    }

    CloseHandle(hDir);
}

The Main Function

The main function sets up the benchmarking environment, runs the benchmarks, and prints the results.

std::wstring directory = argv[1];
const auto arg2 = argc > 2 ? std::wstring_view(argv[2]) : std::wstring_view{};

std::vector<std::pair<std::wstring, std::function<void(std::vector<FileInfo>&)>>> benchmarks = {
    {L"FindFirstFileEx (Basic)", [&](std::vector<FileInfo>& files) {
        BenchmarkFindFirstFileEx(directory, files, FindExInfoBasic, 0);
    }},
    {L"FindFirstFileEx (Standard)", [&](std::vector<FileInfo>& files) {
        BenchmarkFindFirstFileEx(directory, files, FindExInfoStandard, 0);
    }},
    {L"FindFirstFileEx (Large Fetch)", [&](std::vector<FileInfo>& files) {	BenchmarkFindFirstFileEx(directory, files, FindExInfoStandard, FIND_FIRST_EX_LARGE_FETCH);
    }},
    {L"GetFileAttributesEx", [&](std::vector<FileInfo>& files) {
        BenchmarkGetFileAttributesEx(directory, files);
    }},
    {L"std::filesystem", [&](std::vector<FileInfo>& files) {
        BenchmarkStdFilesystem(directory, files);
        }},
    {L"GetFileInformationByHandleEx", [&](std::vector<FileInfo>& files) {
        BenchmarkGetFileInformationByHandleEx(directory, files);
    }}
};

std::vector<std::pair<std::wstring, double>> results;

for (const auto& benchmark : benchmarks) {
    std::vector<FileInfo> files;
    files.reserve(2000); // Reserve space outside the timing measurement

    auto start = std::chrono::high_resolution_clock::now();
    benchmark.second(files);
    auto end = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double> elapsed = end - start;
    results.emplace_back(benchmark.first, elapsed.count());
}

PrintResultsTable(results);

Performance Results

To measure the performance of each file attribute retrieval method, I executed benchmarks on a directory containing 1000, 2000 or 5000 random text files. The tests were performed on a laptop equipped with an Intel i7 4720HQ CPU and an SSD. I measured the time taken by each method and compared the results to determine the fastest approach.

Each test run consisted of two executions: the first with uncached file attributes and the second likely benefiting from system-level caching.

The speedup factor is the factor of the current result compared to the slowest technique in a given run.

1000 files:

Method                         Time (seconds)       Speedup Factor
FindFirstFileEx (Basic)        0.0014831000         162.868
FindFirstFileEx (Standard)     0.0014817000         163.022
FindFirstFileEx (Large Fetch)  0.0011792000         204.842
GetFileAttributesEx            0.2415497000         1.000
std::filesystem                0.0609313000         3.964
GetFileInformationByHandleEx   0.0044168000         54.689

// second run:
Method                         Time (seconds)       Speedup Factor
FindFirstFileEx (Basic)        0.0013805000         44.947
FindFirstFileEx (Standard)     0.0011310000         54.863
FindFirstFileEx (Large Fetch)  0.0009071000         68.404
GetFileAttributesEx            0.0616772000         1.006
std::filesystem                0.0620496000         1.000
GetFileInformationByHandleEx   0.0025246000         24.578

Directory with 2000 files:

Method                         Time (seconds)       Speedup Factor
FindFirstFileEx (Basic)        0.0014455000         150.287
FindFirstFileEx (Standard)     0.0015029000         144.547
FindFirstFileEx (Large Fetch)  0.0012086000         179.745
GetFileAttributesEx            0.2172402000         1.000
std::filesystem                0.0609186000         3.566
GetFileInformationByHandleEx   0.0025069000         86.657

Method                         Time (seconds)       Speedup Factor
FindFirstFileEx (Basic)        0.0012020000         50.908
FindFirstFileEx (Standard)     0.0011614000         52.688
FindFirstFileEx (Large Fetch)  0.0008887000         68.856
GetFileAttributesEx            0.0611920000         1.000
std::filesystem                0.0611760000         1.000
GetFileInformationByHandleEx   0.0025835000         23.686

Directory with 5000 random, small text files:

Method                         Time (seconds)       Speedup Factor
FindFirstFileEx (Basic)        0.0077623000         84.975
FindFirstFileEx (Standard)     0.0828258000         7.964
FindFirstFileEx (Large Fetch)  0.0144611000         45.612
GetFileAttributesEx            0.6595977000         1.000
std::filesystem                0.3022779000         2.182
GetFileInformationByHandleEx   0.0051569000         127.906

Method                         Time (seconds)       Speedup Factor
FindFirstFileEx (Basic)        0.0069814000         43.844
FindFirstFileEx (Standard)     0.0148472000         20.616
FindFirstFileEx (Large Fetch)  0.0140663000         21.761
GetFileAttributesEx            0.3060932000         1.000
std::filesystem                0.3011346000         1.016
GetFileInformationByHandleEx   0.0051614000         59.304

The results consistently showed that FindFirstFileEx with the Standard flag was the fastest method in uncached scenarios, offering speedups up to 129x compared to GetFileAttributesEx. However, in cached scenarios, FindFirstFileEx (Basic and Standard) achieved over 50x speedup improvements. The parameters for “Large Fetch” seems to increase the performance.

For the directory with 2000 files, FindFirstFileEx (Basic) demonstrated a speedup factor of over 179x in the first run and went down to 68 in the second run. In the directory with 5000 files, we can see that GetFileInformationByHandleEx takes crown and acheives 59x speedup, while other techniques reaches 43x max. Notably, std::filesystem performed on par with GetFileAttributesEx .

Further Techniques

Getting file attributes is only part of the story, and while important, they may contribute to only a small portion of the overall performance for the whole project. The Visual Assist team, who contributed to this article, improved their initial parse time performance by avoiding GetFileAttributes[Ex] using the same techniques as this article. But Visual Assist also improved performance through further techniques. My simple benchmark showed 50x speedups, but we cannot directly compare it with the final Visual Assist, as the tool does many more things with files.

The main item being optimised was the initial parse, where VA builds a symbol database when a project is opened for the first time. This involves parsing all code and all headers. They decided that it’s a reasonable assumption that headers won’t change while a project is being loaded, and so the file access is cached during the initial parse, avoiding the filesystem entirely. (Changes after a project has been parsed the first time are, of course, still caught.) The combination of switching to a much faster method for checking filetimes and then avoiding file IO completely contributed to the up-to-15-times-faster performance improvement they saw in version 2024.1 at the beginning of this year.

Read further details on their blog Visual Assist 2024.1 release post – January 2024 and Catching up with VA: Our most recent performance updates – Tomato Soup.

Summary

In the text, we went through a benchmark that compares several techniques for fetching file attributes. In short, it’s best to gather attributes at the same time as you iterate through the directory – using FindFirstFileEx or via GetFileInformationByHandleEx. So if you want to do this operation hundreds of times, it’s best to measure time and choose the best technique. What’s more, if you expect to have lots of files in a directory it’s good to check techniques offering larger buffers.

The benchmark also showed one feature: while C++17 and its filesystem library offer a robust and standardized way to work with files and directories, it can be limited in terms of performance. In many cases, if you need super optimal performance, you need to open the hood and work with the specific operating system API.

Back to you

• Do you use std::filesystem for tasks involving hundreds of files?
• Do you know other techniques that offer greater performance when working with files?

Share your comments below. And if you’re using C++, you can also download and try Visual Assist yourself for 30 days for free.

The post How to Query File Attributes 50x faster on Windows first appeared on Tomato Soup.

Here’s a breakdown of what’s new in this version:

New Features:

1. Context-sensitive Naming in Quick Action and Refactoring menu items (Shift + Alt + Q)

The Quick Action and Refactoring menu is a powerful menu that shows different options depending on the context and the placement of the text caret. For instance, it changes depending on whether you are on a symbol, include directive, or whitespace—and with or without a selection.

In this release, the menu will now take into consideration other symbols and applicable features that will make naming much more intuitive and inclusive of more possible actions. This also marks the start of making some of our menus more ubiquitous. 

2. Improved Read and Write Reference Highlighting

This adds an option to disable the highlighting of references when it is not needed. This is to improve readability and reduce visual clutter.

Specifically, read and write references will now stop highlighting as soon as you move your mouse away from the reference. This keeps your workspace clean while maintaining the ability to easily locate references when needed.

Visual Assist’s highlighting.

3. Feature: Sort Methods in Source (Beta)

We’re excited to release the Sort Methods in Source feature as a beta version! This feature allows you to quickly organize and sort methods in your source files, making it easier to keepnavigate large codebases organised. We welcome your feedback as we refine this feature for future updates.

4. Feature: Promote Lambda to Method (Beta)

The Promote Lambda to Method refactoringfeature is now available in beta. This feature allows you to easily convert lambda functions into regular methods, helping to streamline your code structure and improve readability. 

It is particularly useful for instances where you would like to reuse the same function in other places in the code. This feature takes that lambda and promotes it to a method in the corresponding class for it. 

Test it out and let us know how we can improve it! The settings can be found under the refactorings menu under Extensions under VisualAssistX, or just right click while in a lambda.

5. VA Nav Bar Dropdown for Project Switching

Switching between projects has never been easier! The VA Navigation Bar now allows you to seamlessly switch between multiple projects within your solution. This improvement makes project navigation faster and more intuitive—especially when working in large, multi-project environments that may have distinct code undefined in other workspaces.

6. New reserved string for VA code snippets

VA’s code snippets will now have more reserved string keywords for finding specific parent folders. Reserved strings are keywords that automatically expand when a VA Snippet is invoked. A reserved string obtains its value from an IDE setting, project property, system setting, or surrounding code.

In this case, we added a reserved string for automatically inputting the directory to the Cmake parent folder.

Reserved strings are grouped by type, and can be inserted in the VA Snippet editor via context menu, toolbar button, or keyboard shortcut (Ctrl+I).

7. Option to Adjust Overwrite Behavior When Accepting a Completion

Set up overwriting behavior options Visual Assist Extensions Options ? Enhanced Listboxes.

You can now choose how Visual Assist handles suggestions from a listbox. For instance, when you’re typing in between a word, VA would suggest to complete what you are typing. 

There are different results depending on whether the symbol succeeding the caret is known. If it is not a known symbol, VA overwrites the entire text after the caret with the auto-complete suggestion.

In any case, you can now choose the behavior of overwriting by navigating to the Visual Assist Extensions Options ?  Enhanced Listboxes ? Overwrite text when accepting from a listbox.

Bug fixes and improvements:

• Fixed error when renaming items in particular cases
• Fixed Move implementation header file error when on first line
• Fixed quick info menu not showing all options properly when enabled.

? Availability & Feedback

This release is available starting September 30  and can be downloaded via the Whole Tomato downloads page. As always, we encourage your feedback, especially on beta and alpha features, to help us continue improving and delivering the best experience for developers.

Thank you for your continued support and happy coding! If you have any questions or encounter any issues, feel free to reach out to our support team.

The post Visual Assist 2024.7 release post first appeared on Tomato Soup.

Visual Assist has been a longtime partner for coding in Visual Studio. It adds missing features and sometimes even replaces the default features in the IDE. In fact, you can even argue that Visual Assist had a direct influence as to how some of the features in Visual Studio panned out.

But what makes Visual Assist (VA) such a compelling purchase? And what about it makes it a worthwhile software to continue using?

In this blog post, we share a story of how a small company that invested in VA a long time ago still remains staunch VA users despite numerous new alternatives available. Read on to find out what it is that keeps them renewing each year.

–

We found Ryan, a user who was director at a small software company developing games. They were the type of person who wanted to make sure that his team (no matter how small) had access to the best tools and resources needed to deliver good quality in reasonable delivery time.

The key word here is reasonable. Their reasoning was that in order to create “high quality” work, they had to foster a working environment and workstation that made it easy to be productive. He didn’t feel obligated to have ultra high-end PCs, posh offices, or crazy setups but they did invest into software until work felt easy and frictionless.

For Ryan, a frictionless workstation means that they had access to sophisticated enough tools that allowed them to focus on innovating and problem solving. They had built a reliable set of software: modeling tools, profilers, code analyzers, and coding assistants that made work comfortable—they didn’t have to do things 100% manually, they had tools smart enough to minimize their actions, and they could automate simple and repetitive tasks.

Making navigation faster and easier: Visual Assist’s Find Symbol

In the span of collecting and adding to their suite of software, they found Visual Assist, a productivity plugin for Visual Studio. They had a pain point in navigating projects that made their daily experience with their IDE cumbersome and uncomfortable, ergo bad for productivity.

–

Specifically, they were looking for a “find symbol” type navigation for Visual Studio C++. Particularly when they were browsing a large codebase, and they wanted to find some specific functionality but they did not know exactly what it will be called or where it will be. They needed a dialog box that would search for any symbol across opened and unopened workspaces and reactively respond and filter based on the string the user starts to type in. They expect the dialog to show classes and files (and much more) matching what the string query is.

The problem was that, while it was available in Visual Studio, the search results had to be searched manually across a scattered list of possible dialogs that were searched by: files by name, only symbols in the currently opened file, symbols in all opened files, and text across files (was experimental then).

Furthermore, it was unsuitable because of the matching and search algorithm that the default IDE is using. They needed something that can understand a more abstracted and an unexact version—they were looking for a ubiquitous search dialog with fuzzy search that performed well even on large code bases. 

That’s when they found Visual Assist. Here’s a quick comparison of how Visual Assist compares with the default IDE. 

The native find symbol feature in Visual Studio.

Visual Assist’s improved find symbol dialog. Provides more options.

By happenstance, it was recommended to them from an external developer and it fit exactly what they were looking for. It also did not mess with existing work pattern (and muscle memory) because it was just a plugin that added or augmented their current IDE for C/C++ and C# (i.e. easy deployment).

The Visual Assist plugin they added had a more comprehensive, powerful, and sophisticated search dialog that was both as performant as it was smart. It had fuzzy searching that made project navigation simpler. And it also had a much more intuitive and easy-to-use UI wherein they only have to click to configure instead of grappling with multiple different dialogs (minimized required actions).

Fifteen minutes saved daily, becomes an hour saved weekly, and becomes almost an entire workday’s worth in one and a half months.

Discovering something unexpected: Visual Assist’s Code Refactoring

After a few months of using Visual Assist, Ryan and team then discovered that their newly acquired plugin was a solution for another problem they didn’t know they had. This is one of those cases wherein before you discover that there was a better way to do it, you wouldn’t know how inefficient you were. 

The phantom pain point they had was maintaining code. Refactoring (translating and maintaining) code bases was a cumbersome and eye-straining process. It dealt with unfamiliar, often outdated code. While working on some deprecated projects or shelved projects, they had to update existing source to more modern C++ standards or more scalable code styles. This often involved manual checking and error-prone manual techniques.

With Visual Assist’s code refactoring and navigation support, the team was able to reduce code duplication and augment their intention actions when applying refactoring techniques. 

For example:

• Read unfamiliar code as if they were your own: There is a feature that allows users to extract a method from a long function, after which users can either refactor, rewrite, rename, and reuse the method. They no longer had to fully comprehend unfamiliar code (e.g. code that was just inherited from a colleague no longer on the team) just to refactor them for the current project.
• Get method placeholders instantly: Write out a class declaration and then have Visual Assist write the stubs for the member definitions for you in the corresponding source file, rename variables across the whole project,
• Find and jump to declarations: Search for declarations/definitions faster than IntelliSense can find them, open a file anywhere in the solution in only a few keystrokes, etc. It’s quite handy and easy to use.

VA’s Renaming feature which shows instances of a variable, its context, and available options in one convenient dialog. This made searching, refactoring code, and writing new code faster by about 20%.

It’s like discovering a new shortcut to your office that makes your daily commute a few minutes faster—it seems like a marginal gain, but you realize it’s a task you do on a daily basis. 

That’s what they found with Visual Assist. Even if they weren’t actively looking for it, regular and continuous usage opened new opportunities to optimize their refactoring process. After discovering it, it would be difficult to revert to the original, more lengthy process.

–

To summarize:

• • It adequately solved multiple pain points.
  • It was inexpensive.
  • It was easily deployable to their current workflow.
  • It made their workflow more comfortable and efficient.

Making a case for investments in software

Unfortunately, there are many software companies that miss the importance of providing tools like these. Or in other words, they may not deem these as necessities as much as their developers. There are two ways to look at it. You are either the developer/end user, or you are the C-level procurement officer.

The goal of this post (apart from sharing a success story) is to show how to present a case to management that developers benefit from a comfortable environment, and that would require some investment in software. Otherwise, it’s like giving someone a hammer with no nails and expecting a house to be built in a reasonable time. Craftspeople need good tools. You might have a hammer and nails, but what if your only hammer is a rubber mallet? You’d be incredibly happy to finally get a metal nail hammer.

–

When you present a case (or when a case is presented to you), the normal reaction is to expect a numerical prediction of the returns. But as you may have surmised from the two examples we mentioned above, it’s not that simple for software tools:

• It’s hard to quantify productivity.
• There are some things you can only discover after using the tool.

However, that is not to say that it’s impossible to make a case for a tool. In Ryan’s case, his team was dealing with frustration in locating and navigating certain symbols. That’s expected because in Unreal’s sample shooter game alone, there are around 30 000 defined symbols, 1200 files and headers, and even more references to and from your symbols. What more could a full-fledged project be? 

At that point, it was obvious that simple navigation was a friction point in their daily workflow. If your hammer had a bendable handle you could argue that it’s still usable and could be enough to help build a simple structure. But with each successive swing, frustration and fatigue builds up. This also happens with developers in front of their computer. 

Now, even without a numerical representation, it becomes easier to convince decision makers that this tool is worth it just by simply observing how comfortable it makes developers in their workstation. (That’s why software tools often have free trial periods!)

–

Finally, it’s important to note that not unlike the coding development environment, tools and plugins require mastery as well. When you make a case for investments, it’s important to note that the value of a tool increases over time as users become more accustomed to it.

Before Ryan’s team first discovered VA’s refactoring features, the team had to rely on their own expertise and knowledge to refactor code bases. They first had to understand it themselves and then they had to rewrite code based on the latest coding standards and guidelines.

Overtime, they found that VA was intelligent enough to not only make navigating and reading code easier, it could actually do it for them. If you’ve ever done any coding or similar thinking-heavy tasks, you’d know that that brief moment can make you lose that train of thought you had—that happens often during coding. But with a coding assistant like Visual Assist, you get intelligent dialogs that show you everything you need to know. You can get suggestions as you write, meaning you get timely prompts so you can focus. You can even get it to write blocks of code for you automatically.

Here’s the bottom line: a refactoring tool like VA reduces distracted time and increases their productivity by letting them focus on the real essence of the application (the code) and less on the plumbing (jumping from page to page  for a single symbol definition).

Conclusion

There is no singular approach to finding out what or what not to invest in. And similarly, there is no magic bullet that will fix all productivity problems. But Ryan’s mindset on what his team needed and how he perceived the impact of a solution is a great start. 

The key takeaway here is how important it is to have a comfortable workstation because you can radically lower your productivity and your quality output if you’re not provided adequate tools to fulfill your job. Apart from price and other technical factors, buying decisions should also be based on how much it benefits you and your team.

Try Visual Assist

Interested in getting the same benefits for you or your team?

Whether you’re looking to boost your team’s productivity or optimizing your own development process, you can try out Visual Assist for yourself and understand yourself why Ryan’s team continue to use it until today.

The post Making a case for investing in software tools: convincing yourself, your team, and your boss first appeared on Tomato Soup.

IMPORTANT: Users of 2024.5 should upgrade as soon as possible, or install the previous version 2024.4.
To get the latest version, visit our website now and download the new update.

Visual Assist 2024.6 brings two critical fixes for Visual Assist’s interaction with Visual Studio.

• The first fix in this release addresses a critical issue that could sometimes cause Visual Studio to crash when saving files. This fix enhances the stability of the IDE, ensuring a smoother and more reliable experience while working on your projects.
• Secondly, we have resolved an issue where the Visual Studio installer would crash on versions of Windows older than Windows 10. This fix ensures that users running older operating systems can install and update Visual Studio without encountering disruptions. This should provide a seamless setup experience across all supported Visual Assist-supported versions of Visual Studio.

We appreciate your patience and feedback as we continue to improve Visual Assist for all our users. Please continue to report issues and we will do our best to get them sorted out quickly.

The post Visual Assist 2024.6 release post – Important fixes for Visual Studio first appeared on Tomato Soup.

VA had significant improvements in 2024, particularly in the initial startup time for projects, as well as in the responsiveness of a few key features. It is not farfetched to say that performance has been the primary consideration for the development direction of the plugin.

Why? Because performant, responsive software is productive software, and fast interaction is key to you getting your work done.

We have a lot of solid, robust features based purely on providing not the kitchen sink, but what you need. We already had a reputation for being faster than other products. Now we are even faster: VA is a lean, mean, coding machine.

We’re midway through the year, and we’re summarizing all the recent performance updates in this handy update blog. Read on further to get a more complete picture of when and why these changes were introduced to VA.

Faster startup sequence

Whatever task you have, you first must open and launch Visual Studio—along with any installed plugins you have. Opening a Visual Studio-associated file initiates the startup process which starts loading the essential IDE assets, the solution files you have chosen, and ultimately any auxiliary components like Visual Assist.

While we cannot alter the core loadout of Visual Studio, we’ve worked on every facet of our tool that can be optimized for faster startup:

• Project initial parsing
  

  Project parsing is an extra step that code assistant plugins like Visual Assist need to undertake. VA uses its own parser independent of Visual Studio’s which allows it to pre-scan projects so it can be faster, smarter, and able to provide different functions.
  
  The release in January 2024 featured an overhaul of the parser, which reduced startup times for opening previously unparsed project files by up to 15 times.
  
  While an initial parse is only done the first time you open a project. The next time you open it, it will be instant. (This was an existing feature.) However, we made it 15x faster for those of you who are opening multiple new projects on a more frequent basis.

  For example, an Unreal Engine project with its typically massive code base previously took 15 minutes to parse. We’ve brought this down to a mere one minute of parsing.

  Tech details: Visual Assist implemented a cache for parsed directories to bypass slow Windows file IO API calls where the same call is expected to give the same result—this significantly reduced the initial parse time.

   

• Plugin load time
  

  This update refers to the time it takes for Visual Assist’s features to become functional. As mentioned above, the time-to-functional is the sum of all Visual Studio’s startup routine which includes loading in plugins.
  Every time you close and open a solution, VA’s features take a few moments to load—or at least that’s how it was before. With this update, time-to-functional is more or less instantaneous even in extremely large solutions! 

  As soon as Visual Studio calls on Visual Assist to start loading, you’ll immediately see coloring and syntax highlighting, and have access to all navigation and features. (Note: How Visual Studio initializes plugins and components is indeterminate; results may vary slightly depending on how many components it loads first before Visual Assist.)

  What these changes mean for you:

   

  Depending on how often you need it, the Visual Studio startup sequence and project load can be a part of your feedback cycle when testing and coding. And even a mere 30 seconds are painful and a threat to productivity when repeated, especially when they add up in a work week.

  This is even more pronounced when your work entails opening new projects multiple times in a week. Visual Assist is the best in-class plugin that offers significantly less startup time—giving you more time to be productive.

  READ: Visual Assist startup duration update

Search dialogs: Find References and File Finding

Since starting our crusade against a slow and unresponsive IDE,  there have been two updates that shortened the loading time for finding references and symbols. Utilizing techniques such as parallelism and removing extraneous string searches, you’ll  enjoy up to ten times faster search time.  

Furthermore, better accuracy and new functionality has been added for other search dialogs, including fuzzy search for Open File in Solution.

• Find references speed and responsiveness

Find references is a feature that looks for symbol usage within the current project or solution. Depending on the project size, there may be hundreds to thousands of symbol definitions in your solution, and many of those, tens of thousands of times they may be used. In order for code navigation to work, VA must scour its database for the correct results.

Find references time increases with the number of symbols in the database. However, VA’s feature has been greatly improved for performance and speed—almost ten times faster than before! That means that this performance improvement applies to many key features and navigations.

Some other common and key features in VA improved by this change: 

• Renaming finds references in order to rename them.
• Implement Methods finds methods in order to know which ones do and do not exist
• Change signature works similarly.
  
  

  Visual Assist’s Find references window. Takes significantly less time to find all references in 2024.3.

• Fuzzy search and uppercase search for opening files and searching symbols
  

  Fuzzy search is a technique used in searches and information retrieval to find approximate matches for a given query, accommodating variations like typos and misspellings. It employs string distance metrics to measure the similarity between strings.
  
  Apart from being fast, Open File in Solution and Find Symbol in Solution support this technique, so you can expect more meaningful results with fewer, less accurate search queries.
  
  Furthermore, beyond fuzzy searching for inexact matches, VA will also match capital letters. For example, if you have a class named MyClassName, searching for “mcn” would find it. Similarly, suppose you have a global variable named myGlobalVariable and type “mgv” – the lowercase “my” is treated as if it were MyGlobalVariable, providing expected results.
  

• Move Class feature
  

  Refactoring and moving entire classes can be a hassle. This feature has completed its beta phase to provide full support for porting an entire class to the file(s) of your choosing.

• Bonus QoL Change: Select all items in open file in solution (Ctrl + A)
  

  You can now select and highlight multiple files and open them simultaneously when using open file in solution. The usual shortcut Ctrl + A works.
  

  What these changes mean for you:

  As a C++ developer, you frequently search for files and symbols in massive projects. So even small reductions in wait times or interruptions cumulatively boost your overall productivity to a significant degree.

Summary

Performance improvements are and will remain the focus of Visual Assist in upcoming releases. As projects grow larger and C++ features grow in complexity, we too must adapt and scale our performance to meet the increasing workload and demands on our parser and product capabilities.

This is our most important aim: speedy performance and accurate responses so you can focus on thinking and problem solving—the crucial parts of coding.

We’re only halfway through the year, so let us know what we should improve upon next. Thank you for your continued use and support of Visual Assist!

The post Catching up with VA: Our most recent performance updates first appeared on Tomato Soup.

We hope you find this release useful. Visit our website to download the release.

ARM support

Big news for Visual Assist’s device support! Windows ARM is now supported starting this release, Visual Assist 2024.4. Visual Assist is now available as a fully ARM-native plugin, fully supported in Visual Studio’s ARM build. This means that Visual Assist is now fully compatible for those of you using Macs or Windows devices with an ARM processor. 

We first asked our community about ARM support some time ago. At the time, while it was clear ARM was growing for Macs, it was unclear how strongly it would grow for Windows and we planned support at a future time. Since then, we’ve seen growing interest and customer requests – and we’re happy to deliver! The appearance we see is that many people, including large companies, are increasingly interested in or using ARM for Windows.

There are many advantages to using Windows ARM devices, from battery usage to performance. One key one is that many developers target ARM devices and are used to debug remotely; while debugging on-device or on-simulator remains important, it can be slow and doing minute-to-minute development on a device that shares the same CPU architecture can be very useful.

ARM is a completely new front for us and we would like to know more about how we can improve the experience for ARM users. If you’re part of the group that would benefit from this update, please let us know more by answering this short survey.

Path “/” delimiter

This simple change adds an option for users who are used to using “/” as path delimiters for searching directories. This comes at the heel of users from different operating systems sharing how their default style of delimiter is not supported. 

With this change, you can now choose what the default delimiter will be used. This will apply to most of Visual Assist’s search windows such as Open file in solution and the like.

Bug fixes and improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The highlights are a fix for recognizing one of the features in the standard library. 

The complete list is below: 

• Fixed issue where std::tuple would not be recognized in some cases.
• Move Class to New File will no longer jump to a new file before showing the dialog.
• Fixed broken Discord invite link.

Send us a message or start a thread on the user forums for bug reports or suggestions. Don’t forget to join our Discord too!

Visit our download page to update to the latest release manually. Happy coding!

The post Visual Assist 2024.4 release post – ARM Support first appeared on Tomato Soup.

Download the release now from our website.

Better find references results in multiple faster features

If you’ve updated to at least Visual Assist 2024.1, you may have been enjoying the benefits of the significantly improved parser performance that cut initial parsing time fifteenfold. In this release, we’ve added something even bigger: performance improvements not at startup, but all the time

Find references, the feature that looks for symbol usage within the current project or solution, has been greatly improved for performance and speed. But the Find References engine is used for many other common and key features in Visual Assist! Renaming finds references in order to rename them; implement methods finds methods in order to know which ones do and do not exist; and so forth. That means that this performance improvement applies to many key features and navigations; Rename, Change Signature, Implement Methods and more.

Visual Assist’s Find references window. Takes significantly less time to find all references in 2024.3.

Test Results

The development team ran a few tests to compare the performance of find references between the new Visual Assist version versus an older version of the same plugin. Furthermore, they also tested it against the performance of Visual Studio’s default Find References. 

The test was done on Unreal Engine 5.3 source code using Lyra game examples with two symbols: TOptional and MakeBox as the basis for which references are to be searched. The test was done using Visual Studio 2022 17.8 and Visual Assist 2024.3 & 2024.2. Time was measured from the start of Find References to all references found.

The result of the tests are as follows:

Setup 1 – TOptional:

Setup 2 – MakeBox:

As one can surmise from the results, the latest update brings Visual Assist’s symbol finding performance well above that of default Visual Studio’s and other similar plugins. Further testing on other platforms will be undertaken. Please refer back to this page later for more testing.

Exiting Beta: CUDA core development support & Move Class feature

Two VA features enter their stable phase and are now on general availability. If you have not tried these yet, we highly recommend trying them out as it provides a lot of usefulness that might not be readily apparent.

• CUDA support
  First added in 2023.4, CUDA support allowed Visual Assist to recognize CUDA files and parse and highlight them like regular C/C++ files. This feature now enters full supported status and you can reliably use Intellisense-like features for CUDA files.
• Move Class feature
  Refactoring and moving entire classes can sometimes be a hassle. This feature moves from beta to supported status and allows you to easily choose an entire class and port it over to file/s of your choosing.

Create File: specify a directory + auto implementation.

This is a tiny but useful quality of life change for creating files. Prior to this change, Visual Assist would sometimes display a failure error and ask you if you wanted to Create File or to stop if a target was not found. Now, it runs create file automatically and you can hit Cancel instead.

Furthermore, a bug fix for when using create file: Visual Assist will consistently move the implementation afterwards. (In the past, it sometimes failed to do so.) 

These two changes will hopefully make your experience more seamless and intuitive.

Discord link and feedback options in the Help menu

Introducing our newly opened Discord server for all Visual Assist users. We’re hoping for this hub to function like our forums wherein users can request for changes, report bugs, and share useful information and tips around the plugin.

As it’s a WIP, anyone who is interested in helping us manage and build the community is welcome to do so. Send us a message here if you’re interested.

Furthermore, we’ve added new feedback channels in one of our menus. Navigate to Help and browse new feedback options and let us know what you think!

Bug fixes and improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The complete list is below: 

• Fixed issue where Move Implementation would not move the implementation if a new file needed to be created.
• Improved editor performance when editing C#.
• Fixed Add Include issue where C headers would sometimes be added instead of their C++ counterparts.
• Fixed issue where Move Class to New File would sometimes not be offered near macros.

Send us a message or start a thread on the user forums for bug reports or suggestions.

Visit our download page to update to the latest release manually. Happy coding!

The post Visual Assist 2024.3 release post first appeared on Tomato Soup.

Download the release now from our website.

Significantly faster plugin startup time—especially in large solutions.

This update refers to the time it takes for Visual Assist’s features to become functional. Every time you close and open a solution, the plugin’s features take a few moments to load—or at least that’s how it was before. With this update, time-to-functional is more or less instantaneous even in extremely large solutions! 

As soon as Visual Studio calls on Visual Assist to start loading, you can immediately see coloring, syntax highlighting, and all the navigation and features are accessible. (Note: How Visual Studio initializes plugins and components is indeterminate; results may vary slightly depending on how many components it loads first before Visual Assist.)

This is not to be confused with the initial parse time update that we did in VA 2024.1 which is only a one-time process that happens with each new solution.

Further improvement to our initial parse time.

As mentioned above, we made significant improvement with the initial project parsing. Most of the benefits from 2024.1 were the result of optimizing how Visual Assist goes through files as it traverses references and includes. 

To summarize, Visual Assist used a cache for parsed directories so that it does not have to access the hard disk when an include is referenced multiple times—this significantly reduced the initial parse time.

In 2022.2, however, the developers have squeezed more performance by optimizing smaller items such as string operations, parse logic, etc. This produced a relatively modest but still significant decrease in project parse time.The result is a up to 50% faster parse time versus the previous version. Or in absolute units, that means VA 2024.2 is around 20 seconds faster than VA 2024.1 in our test scenario, where the Lyra demo is now ready in under a minute.

Testing:

Initial parsing time is defined as the point where the Visual Assist starts parsing up to the end where it completes it. This project used the latest Visual Studio 2022 version 17.8.6, again on the Lyra sample game project provided by Epic Games. This is using the same high-end PC and laptop setup used to test the 2024.1 changes.

Setup 1:

Setup 2: 1.19x faster

Setup 3: 1.54x faster

Improved add include for Unreal Engine.

Adding includes when working with Unreal projects has been improved in two ways. First, add include formatting in C++ generally uses either alligator brackets or quotation marks. Generally, <> are for system includes and “” are for user includes, however, there is a stylistic convention when working with Unreal. 

This update adds logic such that when you’re adding includes in an Unreal project, Visual Assist will consistently choose quotations—the preferred style for Unreal development.

Second, the include directory that is used when adding includes will now produce more accurate paths. Visual Assist will try to make sense of directory paths, subfolders included. This is especially useful when working with Unreal Engine which is known to arbitrarily produce paths.

Unreal Engine changes how solutions are generated; and while these are not actually used to build your game, these incorrect include directories are still read and used to generate other include paths when adding new includes. VA adds includes perfectly for normal C++ projects, but this situation may pose issues with some UE solutions, because some solutions could have incorrect include paths set up. 

This manifests as very long and unwanted paths, such as this one when adding the player controller: #include “../../../../../../../Source/Runtime/Engine/Classes/GameFramework/PlayerController.h”

Now, VA instead traverses the directory structure and figures out the paths, instead of trusting the solution. We replaced our logic to mostly ignore the include directories given to use by the solution in lue of traversing the directory structure ourselves. This lets us build our own ‘effective’ list of include directories which we will use to generate include paths for new includes.

For the above example, it would now add: #include “GameFramework/PlayerController.h”—which is what you expect and want as a UE developer. 

Fix syntax coloring in C# for Visual Studio 2022.

A recent Visual Studio 2022 update changed an API that Visual Assist uses to provide coloring and syntax highlighting. This update broke Visual Assist’s coloring and syntax highlighting for C#. 

A near total rewrite has been implemented and syntax coloring should be working now. However, there may be a slight difference in how Visual Assist colors C# files as we reoptimize with the rewritten code.

Syntax highlighting and coloring in C++ has remained unaffected but Visual Assist plans on implementing the new API setup for it as well. This should also fix some minor coloring issues. 

Fixed compatibility issues with GitHub Copilot.

Visual Assist is now completely compatible with Copilot, Microsoft’s AI coding assistant. 

Earlier this year, a bug report was filed on our forums describing a situation where Visual Assist seems to be interfering with Copilot’s chat functionality. This has led to the unwanted situation wherein users have to disable either Copilot or Visual Assist, as some features may not work simultaneously.

All known incompatibility issues have been resolved and addressed in 2024.2. If you encounter any similar bugs, please send us a bug report.

Fixed Open File in Solution issue when the filter starts with a dot.

When starting a query with a dot (.), Open File in Solution may sometimes fail to display the expected results. 2024.2 fixed the ‘dot’ filtering which was a common user complaint.

Search filtering features are available by starting with a dot to find files that begin with the filter, or contain the dot and substring. A filter that ends with a dot matches the ends of file names. For example “string.” finds files whose base names end with “string”. This dot filtering is also possible in other dialogs of Visual Assist that support filtering.

Bug Fixes & General Improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The complete list is below.

• Fixed UI conflict with GitHub Copilot.
• Fixed issue where Add Include would sometimes not add the new include.
• Fixed long Add Include paths for some symbols in Unreal Engine 5.3.x.
• Fixed issue where Open File in Solution would sometimes not display results when the filter starts with a dot.
• Fixed issue where C# syntax coloring would not be applied in Visual Studio 2022 17.9.0.
• Fixed issue where readability-magic-numbers Code Inspection would not properly underline hex numbers.
• Fixed issue where GoTo would not navigate to classes without a constructor.
• Fixed issue where suggestions could show suggestions for non-existent types.
• Updated Create Account link to point to the correct page.
• Added Alt+O to Recommended Keyboard Shortcuts as Visual Studio 2022 now uses that binding.

Send us a message or start a thread on the user forums for bug reports or suggestions.

Visit our download page to update to the latest release manually. Happy coding!

The post Visual Assist 2024.2 release post first appeared on Tomato Soup.

Why Visual Studio?

Visual Studio is the de facto IDE for editing Unreal’s C++ projects. Unreal Engine (UE) is designed to integrate smoothly with Visual Studio (VS), allowing you to make source code changes in your projects quickly and easily, and immediately see results upon compilation. Setting up VS to work with UE can help improve efficiency and the overall user experience for developers using UE.

Installing and Getting Set Up

Things You Need to Download Before Doing Everything:

• Visual Studio (VS22 Recommended)
• Epic Games Launcher for Unreal Engine (You download UE using the launcher)
• A sample game project (Optional downloadable from the UE marketplace)

Step 1: Installing Visual Studio

First up, you want to install Visual Studio, the IDE of choice for Unreal Game development. It is recommended to install the latest version of Visual Studio, or any version from VS 2022 to take advantage of 64-bit address space with virtually unlimited memory limit—this will be useful for working with Unreal’s project sizes.

You can pick between a professional (commercial for teams) and a community license (free for individuals). Download the bootstrap .exe and open it to start the installer.

You will then be shown a number of customization options for workloads, additional components, and installation location. For the workloads, which contain components you need for the programming language or platform that you’re using, we recommend installing the following: 

• .NET development
• Desktop development C++
• Game development C++.

Adding Visual Studio Tools for Unreal Engine

Make sure to tick the following items when choosing your workloads.

Visual Studio has come a long way with its integration with Unreal Engine’s features and dev tools. Microsoft has added extra support for Unreal that enables you to add UE classes, view UE logging, and more, all from within Visual Studio.

Step 2: Installing the Unreal Engine editor

Next up, you need to install the Unreal Engine editor. This allows you to open and run pre-cooked versions of the games you will develop. This allows you to run unsaved, uncompressed, and uncompiled programs using the Unreal Engine. This makes it easier to run, edit, tweak, demo, and overall quickly test things in your games.

To download the Unreal Engine editor, you first have to download the Epic Games launcher and follow the installation process. Once you have the Epic Games launcher installed, sign up for an Epic Games account using whatever login option you prefer.

Once you have logged in, you can navigate to the Unreal Engine tab and start downloading the Unreal Editor. This will also install the editor in your system automatically. The most common way to open the Unreal Editor will be through this launcher. You could also double click your *.uproject file or if you prefer, open the Visual Studio solution and then compile and run the editor from there. 

Use the dropdown on the top right to choose which version of Unreal you want to install (in most cases, the latest version will be the best choice.) Follow the instructions and customize your install locations and shortcut options if you prefer.

Tip: There is usually a prompt to associate UE with Visual Studio, but in case it has not followed the succeeding steps. In the “Edit” menu of the Unreal Editor, navigate to “Editor Preferences” and then navigate to the “Source Code” section. Choose the corresponding Visual Studio version as the preferred source code editor.

Step 3: Finding sample project files

Congratulations! You have installed the two primary programs needed for Unreal Engine development. At this point, you will decide whether you would like to use the blueprint visual scripting system or C++. For the purposes of this tutorial, we will go further and set up C++ project files. (Remember for when you progress: it is more efficient if you use both the blueprint system and C++ in tandem.) 

Creating a game from scratch is a gargantuan task. And even with a game engine handy, it may still feel overwhelming. Luckily, Epic provides a number of free sample projects so you can test the waters out and familiarize yourself first before starting a project entirely on your own.

Browse through the marketplace or the sample game projects available inside the Epic Games library. This catalog will include almost every genre of games, tech demos, and sample studios that you can think of. 

Epic Games has provided a number of sample games and projects so you can jump right in and practice your development skills.

For this tutorial, we chose the Lyra Starter game—a sample FPS game continuously updated with the latest UE has to offer. You can easily invest hundreds of hours just tweaking the gameplay, graphics, and user interface systems to get better at the complexities of the C++ integration.Choose and download your sample game of choice and save it on your system.  This will save the game files, preconfig files, and most importantly a *.uproject file—a text file that contains basic settings for your game project, which can be conveniently read by the Unreal Editor to launch your game. This will also be useful for the next step.

Choose your install location and click on create and wait for the process to complete. This will create the essential project files for editing the source code in Visual Studio.

Step 3: Building your first project files and opening for Visual Studio

To open the  downloaded game file source code in Visual Studio, you have to make a Visual Studio project file (or its collective known as solutions).

Navigate to where you created your project files.. If everything was installed correctly, this will have a *.uproject file that will have an entry for the associated source code. This allows you to generate a Visual Studio solution based on the UE Lyra Game source code. Right click on the *.uproject file and click on “Generate Visual Studio project files”.

Right click a *.uproject file to create source folder that contains .cpp and .h files.

This will build a Source folder that contains .cpp source files, .h header files, and a .sln Visual Studio solution file that you can open inside Visual Studio. 

Launch Visual Studio and open the corresponding solution. This will start a short loading process as your project initializes, but don’t worry; it’s just the initial pre-project parsing. Opening the same solutions in the future will take significantly less time.

This process maps out the entire network of source files and builds a database of symbols so that the IDEs navigation and search features work. If you’ve reached this far, congratulations! You have successfully set up Unreal Engine and integrated its source code for development in Visual Studio.

A Lyra game C++ header file opened in Visual Studio.
Note: Syntax highlighting and navigations are added by a nifty tool called Visual Assist—more on that later!

Making changes to your first project

After installation, you may want to start as simply as possible to familiarize yourself with the process of using the Unreal Editor in conjunction with Visual Studio C++ to change or add gameplay mechanics to your sample game. 

You will find that Visual Studio development comes with its own set of workflows before you can see actual results in the editor. You may be writing new code, debugging, or compiling projects. And it may be easy to lose track of what comes after which. 

If you want to get your hands dirty on an actual project, it is highly recommended to watch the following tutorial on how to add a powerup pickup to the sample shooter game. Watch and learn to set up projects, find project files, retrofit existing assets, and write and build your own C++ to make new content.

Watch and learn how a seasoned Unreal dev sets up Visual Studio + Unreal Engine. See how you can use C++ to add your own power up. Watch the tutorial here.

Removing false errors in Unreal Projects

When you first start working on an Unreal solution you will notice that there are syntax and symbols specific to Unreal development. Unfortunately, these symbols and functions can be mislabeled or flagged as false errors by Visual Studio as they are not part of the normal C++ workload. The C++ files will still compile but this caused a lot of confusion, especially among beginners. 

A group of game developers grew tired of the false errors and unresponsiveness of the IDE in large gaming projects, so they built their own tools tailored specifically for Unreal. The developers from Whole Tomato created a plugin called Visual Assist that understands Unreal Engine syntax—improving the frustrating situation they were in.

Overtime, the plugin grew from adding simple syntax comprehension and handy navigations to a full-fledged productivity augmentation for Visual Studio C++. The plugin developed a smart parser that understood what users were trying to accomplish, and thus was able to visually provide timely and contextual assistance in real time.

Red squiggles under source code signify errors. However, these are all normal Unreal Engine code mislabeled by the IDE.

Visual Assist remains one of the top productivity plugins for C++ and Unreal Engine work. It is responsive, performant, and parses your game files extremely fast so you can jump right in with complete support. You can download Visual Assist and try it out for yourself on freshly installed or existing Unreal projects.

The post Installing Unreal Engine 4/5 + Visual Studio: A complete step-by-step guide with pictures first appeared on Tomato Soup.

The makers and developers of Visual Assist will make their return to Moscone Center in San Francisco from March 18-22 for GDC 2024! Whole Tomato will be at booth number P1769 sharing space with a sister company, Assembla! Two of the best tools for game development in one booth—efficient!

GDC has always been one of the most awaited gaming events for video game professionals every year. It’s also one of the few opportunities for us to meet with daring new developers, colleagues in the industry, and of course enthusiastic users. That’s why we are excited to physically meet the community once again in this year’s GDC! 

We hope to see you there!

PS: We will be handing out exciting prizes and giveaways for our booth visitors!

Book an appointment with us

If you’re attending GDC and have access to the conference virtual platform, you can book a meeting with any of team members. Use the link below and navigate to the Teams section and take your pick among our dazzling booth members.

The post See you at San Francisco for GDC 2024! first appeared on Tomato Soup.

The post What’s New in Visual Assist 2024—Featuring lightning fast parser performance [Webinar] first appeared on Tomato Soup.

Great news! The Whole Tomato experience just got even more complete and well-rounded! 

The hobbies and recreational activities you do during your early days in school often become the gateway to the skills you’ll develop and use in the real world. It is no surprise, then, that the tools and machines you use when starting out as a complete novice influence how you grow from a curious enthusiast into a full-blown professional.

This also means that one of the biggest gatekeepers for novices and students learning the basics is access to tools and machines that are fundamental to learning a skill.

This is why Whole Tomato is proud to announce that we’ve recently launched our academic licensing program to help students—as well as their teachers—get a headstart in their programming career!

The benefits for students, instructors, and teaching departments

To help more people learn about the wonders of fast and efficient programming in C, C#, and C++, Whole Tomato is lowering the barriers to accessing its renowned Visual Assist plugin for Visual Studio. From now on, students and instructors can secure fully sponsored Visual Assist licenses.

Visual Assist is kicking off its foray into accessibility for young learners, instructors, and teachers.

For Students
Students can easily secure a license using a verified educational email address. They will be able to purchase discounted licenses—friendly to an apprentice’s allowance. And if a learner is only willing to test the waters, they can also opt for a monthly subscription plan. Just visit our webstore and follow the checkout process for students.

A student is someone who is enrolled in an accredited educational program. Students can also check with their university or program organizers if they have existing packages with Whole Tomato. 

For teachers, instructors, and departments
Sometimes a beginner needs a push in the right direction. Recommending Visual Assist to students has never been easier. If an instructor is looking to share Visual Assist with their class or department, they have access to a number of tiered options ranging from fully sponsored deals to specially tailored plans.

If you’re interested in sharing the unrivaled power of Visual Assist to a class or a group of learners, contact the Whole Tomato sales team to explore your options.

Why an academic licensing program?

Picture this: rolling out academic licenses could be a game-changer, especially with the new generation of developers and programmers in mind. Think of it as guiding the future workforce with a backstage pass to industry-grade tools while they’re still in school. This early exposure to efficient and optimized instruments and applications makes learning a more encouraging and satisfactory experience. 

Partnering up with schools and departments also means that we, as software providers, get a chance to know what the new wave of developers are interested in trying or what problems they are facing. This allows Visual Assist to grow alongside the ever-changing demands of C/C++ development. 

And you students, on the other hand, get a more suitable and optimized tool to help you become fast and efficient developers. You won’t need to train and study as much when you graduate, as well since you will already be accustomed to the tools in the industry. This makes you a more attractive candidate for the occasional picky recruiter.

Supporting young learners is also one of the initiatives that the community should always strive to promote. As an interdependent and ever-changing industry, developers and the software world must ensure that people remain interested in learning our craft. Offering software at student-friendly rates (or even sponsoring them completely) levels the playing field and makes it more accessible. It’s totally the way to go! ?

Why would students need Visual Assist?

Long loading times, incomplete prompts, incorrect suggestions, and missing navigations, among others. The Visual Studio IDE has gone through leaps and bounds to improve C development, however, there are still areas in C++ that are in dire need of improvement.

Visual Assist provides the necessary support  and tooling learners need in their journey to becoming developers. Visual Assist provides new tools and improves existing ones in VS to eliminate the frustration in C/C++ development.

The latest additions to Visual Assist

Visual Studio 2022 
Cash in on that sweet x64 process. With virtually limitless memory available to Visual Studio, your productivity plugins no longer have to squeeze themselves for the remaining memory allocation. Visual Assist has been tweaked to properly utilize the newfound bandwidth.

Extremely fast project parsing
Interruptions and long loading times can make a significant hit on productivity. Stop fighting your development environment. Visual Assist’s raw performance allows users to focus on thinking and coding.

Better coding support and tooling
It’s easier to teach new learners new things. Visual Assist keeps the development environment updated with the latest features available. Follow the latest C++ standards and conventions with VA’s 100+ New code inspection checks and updated LLVM Clang Tidy 15.0 engine.

Specialized support
Unreal Engine source, shader files, CUDA core development, you name it. Visual Assist adds special support for lookalike C++ code. Enable basic IDE features such as navigations, refactoring, and code completion for these applications.

 The best time to get Visual Assist

Visual Assist was running at a discounted price when we publicly launched academic licenses—but luckily for you, being a student or a teacher ain’t seasonal! Visual Assist academic licenses will be available continuously for students using our webstore. And if you’re an instructor looking to secure some seats for your students, just contact our sales team to browse your fully-sponsored options.

Not a student or a teacher but you’re looking for affordable sets of licenses? Not a problem! Contact us to check your available options for bulk and enterprise licensing.

The post Another reason to cheer: Visual Assist academic licenses! first appeared on Tomato Soup.

We also have a new code checker, support for two new C++ language features, and small but useful improvements to VA’s behavior. Read on further to get the complete details of the changes and improvements in this release, or download the release right away.

Share source code via email, GitHub, and more.

Starting from VA 2023.6, users can now highlight sections of code from the editor and open the Quick Actions and Refactoring (Shift + Alt + Q) menu, or right-click on the code and select the “Share with team member” option to instantly send code to other developers.

Select and share sections of code by highlighting it and using the Quick Actions
menu (Shift + Alt + Q).

Choose where and how you want to share your code. This new feature can work in conjunction with GitHub Gist and GitLab’s snippets feature, where you can instantly share and upload parts of your source code. You can also send your source code via email for more general-use purposes. 

Improvements to VA’s navigation features

This release provides a number of improvements and additional functionality to VA’s bread and butter navigation features, such as open file in solution and find symbol in solution.

• Fuzzy search and uppercase search for opening files and searching symbols
  Fuzzy search is a technique used in searches and information retrieval to find approximate matches for a given query, accommodating variations like typos and misspellings. It employs string distance metrics to measure the similarity between strings.
  
  Visual Assist’s open file in solution and find symbol in solution will now employ this algorithm, so you can expect more results with fewer, less accurate search queries.
  
  Furthermore, besides fuzzy searching for inexact matches, VA will also match capital letters. If you have a class named MyClassName, searching for “mcn” would find it. It works similarly if you have a global variable named myGlobalVariable and type “mgv”. It is smart enough to count the lowercase “my” as if it were MyGlobalVariable leading to expected results.
  
  

  Enable fuzzy search and see smarter search results using approximate string matching.

   

   

• Select all items in open file in solution (Ctrl + A)
  You can now select and highlight multiple files and open them simultaneously when using open file in solution. The usual shortcut Ctrl + A works.
  

  Select and open all files with the new select all shortcut.

Improved support for Braced Initialization Lists / Uniform initialization (C++ 11)

2023.6 also improves support for braced initialization of lists and/or uniform initialization. Brace initialization lists and uniform initialization provide a more consistent and flexible way to initialize objects in C++. 

These features  improve code readability and reduce the chances of certain types of errors. Visual Assist’s parser will recognize these lists and highlight and suggest auto corrections within them.

Improved support for constexpr, consteval and constinit  (C++ 20)

These features are related to compile-time evaluation and initialization. They have specific use cases and are used to enforce certain behaviors at compile time. If you haven’t been using these, here’s a quick breakdown:

• constexpr used to indicate that a function or variable can be evaluated at compile time.
• consteval a stricter version, ensuring that the function or expression is only evaluated at compile time and cannot be evaluated at runtime.
• constinit is used to indicate that a variable must be initialized at compile time and, once initialized, its value cannot be changed during the program’s lifetime.

When using these features, Visual Assist will recognize what you are trying to accomplish such as refactoring commands mainly. Refactorings such as Create From Usage will now properly handle these keywords.

New code inspection for detecting “magic-numbers”

This new Clang-based code inspection checks for instances of magic numbers—or numeric literals that are used without any definition—that are advised against by many coding guidelines for readability sake.

Enable code inspections by navigating to Extensions ->> VAssistX ->> Code Inspection ->> Enable code inspections.  This specific code inspection is disabled by default because some users may be intentionally using it and are not interested in “fixing” it.

Then you can either click on detected issues underlined in blue, use the Quick Refactoring Menu (Shift + Alt + Q) while on the highlighted issue, to allow VA to do it for you. In this case, there is no automatic fix so it will prompt you to define a variable with that number as its value and use the variable instead. 

Protip: VA can help do that for you with the introduce variable feature. If you highlight the number, then use the Quick Actions menu and select Introduce Variable it will ask you for a name and pull the number out into a variable for you.

You can read more about the readability-magic-numbers code checker on Clang’s documentation. 

New move class feature

You can now move entire classes into different files with the new move class feature included in 2023.6. 

For example, if you have a class named MyClass, with its declaration in MyClass.h and its definition in MyClass.cpp, you can move the entire class into a new pair of files, MyClassNew.h and MyClassNew.cpp. 

This is useful if you have a header and source file pair (.h and .cpp) that contain multiple classes and you want to break that up into multiple files.

Bug fixes and improvements

For this release, we have a couple of fixes based on user requests. The most notable of these improvements include a fix for file exclusion instructions using .json configs similar to a previous release, a parser improvement for Unreal Engine 5, and improved auto-detect logic for Unity.

• Fixed multiple issues with file exclusion logic when reading from “.vscode\settings.json” configs.  
• Our parser now better understands Unreal Engine 5.0 (specifically that build) types, such as FVector.
• Fixed Create from Usage behavior when used inside const inline methods. 
• Fixed coloring of [[fallthrough]] marked enum items. 
• Attempted to fix rare temporary hang when debugging C# Unity projects.
• Code Inspections options dialog now displays much more quickly. 
• Improved Unity engine auto detect logic to reduce false positives.

Thanks to those who submitted their feedback and bug reports. Please continue sending them our way. Send us a message or start a thread on the user forums for bug reports or suggestions.

You can also check our download page to manually update to the latest release. Happy coding!

The post Visual Assist 2023.6 release post first appeared on Tomato Soup.

As many of our readers know, Visual Assist is a productivity extension for Visual Studio that provides a set of intelligent refactoring, navigation, code highlighting and generation features for C++ development, along with tailored features that help game devs make the most of Visual Studio’s integration with Unreal Engine. For those who are newer to our blog, check out this article for a quick overview of how Visual Assist can make game dev with Unreal Engine easier. In addition, last month was the first version of Visual Assist to officially support Unity. Read more about it in the VA 2023.4 build announcement.

Today, we’d like to introduce you to one of our partners, Assembla, and share how their Perforce hosting offerings can make game dev with Unreal and Unity even more efficient. Assembla provides a cloud-based source code management platform that brings project management, source code hosting, security solutions and other integrations under one roof to streamline your E2E dev pipeline. 

Assembla hosts Perforce Helix Core in the cloud under two solutions: Perforce Cloud, a quick-to-deploy SaaS platform, and Perforce Enterprise, where Assembla DevOps engineers set up Perforce Helix Core in a fully managed, dedicated AWS server or a custom network of servers to support global teams. With Assembla’s solutions, gaming studios save the overhead of managing their own on-prem or cloud solution and can focus on creating the best game possible rather than infrastructure. Additionally, teams can scale globally without worrying about how source control and file transfers will perform across locales.

Assembla was the first company to package Helix Core for the cloud and remains a leading expert today, bringing you the best features: 

• Fast commit performance
• Faster revisions, code testing and binary file handling 
• Automatic backups for every commit
• Virtually unlimited cloud repository storage
• Track and trace any code changes to identify security threats
• Native support for Unreal Engine and Unity
• Helix DAM to help speed up the creative process for your artists and designers
• Helix Swarm for code review

Assembla also supports Perforce’s third-party integrations with standard game dev tools such as Visual Studio, Jira, Adobe, Maya, Microsoft, and AWS. To further streamline your dev pipeline, Assembla recently launched a new CI/CD integration that supports GPU builds through Travis CI, improving the speed and efficiency of processing your games. 

Discover how Assembla can help you make the most of Perforce so you can create virtual worlds and immersive games by visiting their Gaming Development page.

The post Game Development Showcase: Visual Assist + Cloud Hosted Perforce from Assembla first appeared on Tomato Soup.

Std::maps is a staple in the C++ world for sure. It’s reliable and useful, but in this presentation, David Millington goes a level deeper and examines how other features offered beyond the standard library can be used to maximize the usefulness of the data structure. 

Quick Refresher on Maps

Maps are essentially a way to store key-value pairs in an ordered structure. This creates an associative array that can be used to lookup connected pieces of data. Maps are ubiquitous. Value-key lookup is used everywhere: filenames to files, index number to row/column, ID number to name, and the list goes on. 

Maps can be ordered or unordered. They are also similar to static arrays and vectors but they possess a few key differences such as memory management, performance, and appropriate types—watch this section of the webinar to learn more.

Things to Remember from the Webinar

• Where to use std::map and std::undordered_maps
• Difference between maps, static arrays, and vectors
• The many map implementation libraries available
• The importance of iterating in order
• Comparing performance of ordered and unordered maps

Slide Deck Presentation

Replay

The post Summer CodeFest: Magnificent or Malevolent: Maps! Measured, Monitored, & Magnified! [Mrecap] first appeared on Tomato Soup.

This release marks a major milestone in Visual Assist’s history as it starts its official support for Unity engine development. Also in this release: start of support for CUDA development for C/C++ and numerous parser improvements. Read on further to get the complete details of the changes and improvements in this release.

Start of official support for Unity

It’s been a long time coming but Whole Tomato is glad to announce that the upcoming 2023.4 build will feature the first of many Unity-specific features. Nope, not the hivemind—we are of course talking about the very versatile game engine and game development platform.

For those unaware, the Unity engine is the backbone of both 2D and 3D games ranging from wildly popular and suspicious games, all the way to full blown highly-acclaimed triple A titles.

Visual Assist has been popular for helping game developers deal with complex C++ code. Starting from the upcoming release, Visual Assist will expand its focus to C# game development. Users can expect VA staples such as refined navigation, intelligent autocomplete, code refactoring, and the like to work as well for C# work.

Furthermore, users can also submit feature requests specific for Unity development. We are starting with shaders—more on this below—but if you have any suggestions as to what features are missing in your Unity development, do let us know by emailing support.

Shaders for Unity

The start of official support for Unity development is headlined by shader file support. Similar to our previous addition of supporting HLSL, we are kicking off Unity updates by adding its shader files to our list of supported languages.

CUDA C/C++ Development

If you are a data scientist, software engineer, or a plain hobbyist looking to harness the power of your GPU for general purpose programming tasks, then you would most likely know about Compute Unified Device Architecture (CUDA). This programming model developed by Nvidia allows programmers to utilize the multi-core performance of graphics cards for other non-graphic applications (although it’s perfectly fine to use for 2D/3D too!)

If you are interested in CUDA, then rejoice! VA 2023.4 also marks the start of official support for CUDA development. Visual Assist’s can now parse and analyze CUDA related syntax, libraries, and APIs so you can have IntelliSense-like features, navigation, and highlighting for CUDA (.cu) files.

A CUDA file with proper syntax highlighting and code analysis features.

Parser Improvements: template functions with auto / trailing return type and std::tuple autocompletes 

With VA 2023.4 will now properly highlight and parse trailing return type features that bypasses a C++ limitation where the return type of a function template cannot be generalized if the return type depends on the types of the function arguments. This release specifically deals with some of the edge cases reported by our users.

Trailing return type features can be used by declaring a generic return type with the auto keyword before the function identifier, and specifying the exact return type after the function identifier. Learn more about it here.

The parser is aware of sum and proper syntax highlighting and navigation features are applied.

Also fixed in this release are initializations of std::tuple autocompletes. This improves how the VA parser handles certain templated types. In the end, users will find better completion suggestions when you are typing in your codebase, such as when typing std::tuple.

Better Add Include logic

Visual Assist can add include directives for headers that resolve unknown symbols in the current C++ source file. The underlying logic for add include has been improved for better context-awareness resulting in better predictions on where to place the new include.

Add include now inserts new lines in most logical place.

Add include can be accessed by hovering over unknown symbols and opening the quick actions and refactoring menu ( Shift + Alt + Q ).

Some other spring cleaning-type improvements

We’ve also made some changes to a few minor things to the UI and the options in the app that you should know about. Firstly, our shader support has been available for a few rounds of releases already and we’re excited to announce that it has finally finished its beta phase and will now be enabled by default. 

Secondly,  we’ve streamlined our game Development tab of our options dialog. This is to make room for upcoming additions (stay tuned!)

Thirdly, we’ve tweaked some tomatoes and icons along the way to better respond to your actions and better display what options are available to you. Relevant options and menus will be emphasized when they are needed; secondary options will subtly fade into the background otherwise. This is in line with our commitment to distraction free coding.

Lastly, if you’ve missed or haven’t installed the latest version yet, you may have noticed that the Visual Studio marketplace listings for the 32 and 64-bit versions of Visual Assist have now been combined. Versions 2010 – 2022 will now be accessible from one listing.

Bug Fixes

• Fix for ‘VaMenuPackage’ package error affecting VS2022 17.7.0 3.0 load
• Fixed issue where some types with leading macros before template definitions were not parsed correctly.
• Fixed issue where autocomplete of some types, such as std::tuple, would produce partial results.  
• Fixed rendering of suggestion list tomato icons in Visual Studio 2022. 
• Fixed issue where the VA Navigation Bar could become smaller than intended.
• Fixed Code Inspections error that could happen in some cases in Visual Studio 2022 17.6+. 

Thanks to those who submitted their feedback and bug reports. Keep ‘em coming. Send us a message or start a thread on the user forums for bug reports or suggestions.

Contrary to the preview blog statement, VA 2023.4 is a bit different as it will be released simultaneously—no rolling release mechanism as it includes some crucial updates we want to share to everyone as fast as possible. You can also check our download page to manually update to the latest release too. Happy coding!

The post Visual Assist 2023.4 now released first appeared on Tomato Soup.