C++ is used to program and create video games on different platforms.

What This Guide Covers

Whether you’re a complete beginner or transitioning from another engine, this comprehensive guide answers the most common questions about C++ and Unreal Engine development. You’ll learn when C++ is necessary, what alternatives exist, and how to make the best choice for your project goals.

The Short Answer: Blueprints vs C++

You can absolutely create games in Unreal Engine without knowing C++. Unreal’s Blueprint visual scripting system allows you to build complete games using a node-based visual interface instead of traditional code. Many successful indie games have been built entirely with Blueprints.

However, C++ becomes valuable when you need:

• Maximum performance optimization
• Complex gameplay mechanics
• Custom engine modifications
• Integration with third-party libraries
• Advanced AI systems

However to get the most out of UE and improve at the fundamentals, you should not be using blueprints or C++ exclusively. Ideally, you should learn how to use both. If you want to learn more about C++ vs Blueprints , we’ve discussed in another article about when to use Blueprints or C++ when developing games.

Is Unreal Engine good for beginners?

Unreal Engine is a great game engine for beginners as it provides access to a lot of templates and assets completely for free (unless your game earns >$1M gross annually) . However, it is also expansive and powerful enough for experienced developers as well. If you are familiar with other platforms, such as Unity or previous Unreal Engine versions, you will be able to jump right in and start creating video games using Unreal Engine C++. A virtual game and graphic studio that specializes in Unreal Engine C++ development can also be a great resource for learning the language and developing your skills.

The process of developing a game with Unreal Engine is not difficult to understand, but it does require a lot of time and practice, knowledge of the language, and commitment. And one of the very first questions is: where do I begin?

Do you need to know how to code for Unreal Engine?

Creating entire games with Unreal Engine can be a daunting task, but with the right knowledge and skills, you can make amazing programs. Some basic knowledge of coding—and C++ to an extent—is required, but it is not necessary to be an expert. The Unreal Engine is not just intended for developers but also for creators; and a game programmer is not limited to working with Unreal Engine.

It is even possible to create full-fledged games without any coding background. Popular gaming engines like Unity or Unreal Engine offer visual scripting tools or no-code solutions for managing game assets. Unreal has its Blueprint scripting process wherein you can use nodes to replace normal programming logic.

But if you want to dive into the nitty gritty, learning about the fundamental language of which the engine is based on a surefire way to greatly increase both your options and your efficiency. Additionally, many other game development platforms, such as Unity and GameMaker, use similar coding languages. Knowing how to code for these platforms will help you get started in the game development industry.

Learning Path Recommendations for Complete Beginners

1. Start with Blueprint Fundamentals
   • Complete Epic’s Blueprint tutorials
   • Build simple games (Pong, basic platformer)
   • Understand Unreal’s component system
2. Learn Basic C++ Outside Unreal
   • Master fundamental programming concepts
   • Practice with simple console applications
   • Understand object-oriented programming principles
3. Transition to Unreal C++
   • Start with simple C++ components
   • Gradually replace Blueprint functionality with code
   • Learn Unreal-specific C++ conventions and macros

READ MORE: Install and set up Unreal Engine with Visual Studio.

When is C++ essential then?

C++ coding becomes essential when you’re dealing with specific use cases and the blueprints system is not sufficient anymore.

• Performance-Critical Applications

C++ provides direct memory management and system-level control that Blueprint scripting cannot match. For AAA games, VR experiences, or applications requiring 60+ FPS with complex systems, C++ often becomes necessary.

• Advanced Game Systems

While Blueprints excel at prototyping and standard gameplay, certain advanced features require C++ implementation:

• Custom rendering pipelines
• Specialized physics calculations
• Multi-threaded operations
• Platform-specific optimizations

• Professional Development

Most professional game studios expect C++ knowledge for Unreal Engine positions. Understanding both Blueprint and C++ makes you more versatile and employable in the game development industry.

• Custom Gameplay Mechanics

With C++, you can implement complex gameplay logic that goes beyond what is possible with Blueprints. This includes creating custom character controllers, AI behaviors, and game rules.

• Creating components and 3D environments

Components are the basic building blocks of Unreal Engine. Components can be used to create 3D environments, menus, and other user interface elements. These components can be exported to other platforms.

• Advanced AI Systems

Create sophisticated AI systems using C++ for behavior and decision-making processes for non-player characters (NPCs) and other game elements such as custom pathfinding algorithms, decision-making systems, and behavior trees.

• Create logic and integrate with scripts

Logic is the code that controls how players interact with each component. Scripts are a special type of code that is more visual. Using both C++ and scripting for Unreal  allows for seamless development in their games.

• Test and debug games

Testing and debugging games is an important part of the game development process. When you work with mechanics created using C++, verifying that component will most likely require C++ knowledge as well. Problems that can be debugged include crashes, missing textures, and incorrect game logic.

Blueprint vs C++ Performance Reality

When Performance Differences Matter

The performance gap between Blueprint and C++ varies significantly by use case:

• UI and Menu Systems: Minimal difference
• Simple Gameplay Logic: Negligible impact for most games
• Heavy Calculations: C++ shows clear advantages
• Frame-Critical Systems: C++ often necessary for consistent performance

Hybrid Approach Benefits

Most successful Unreal projects use both systems strategically. Learn more here.

• Blueprints for: UI, game flow, designer-friendly tweaking
• C++ for: Core systems, performance-critical code, complex algorithms

Highly Recommended for Unreal C++ 

If you do decide to code using C++ for Unreal Engine, you will most likely download Visual Studio, the official IDE of choice for developing C++ games in Unreal Engine. It provides an extensive list of navigations, refactoring, auto-suggestions and syntax highlighting for C++ development.

However, Visual Studio also caters to C/C# and unfortunately, the support and tooling for C++ may seem relatively weaker at first glance. Furthermore, Unreal Engine has bespoke coding elements and syntax. This may lead to frustrations when developing Unreal C++ games in the IDE because some basic navigations and features such as syntax highlighting may be unresponsive, or may be unavailable completely.

For these cases, it is highly recommended to install a supplementary plugin like Visual Assist which improves the overall IDE experience and replaces the frustrating elements with tailored features made for C++ Unreal Engine development. It makes the IDE features responsive and adds “understanding” so that basic features such as code highlighting, search, and auto-suggestions work properly.

The post Do I Need To Know C++ For Unreal Engine? The Updated 2025 Guide 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.

Luckily, there are certain techniques and technology that developers can utilize to make it a bit easier. Learn more about how cloud-hosted Perforce is something you should be capitalizing on for collaborative Unreal game development in this webinar co-hosted by Whole Tomato and Assembla.

Expect the following in this webinar:

• Know about the benefits of collaborative asset management and remotely managing them.
• Build familiarity with web-based version control and source code management software
• Set up an Unreal game project to sync with remotely hosted perforce server and productivity tools

The webinar is happening on February 22nd, Wednesday 10 AM CST and will be presented by Whole Tomato’s own lead engineer and product manager, Chris Gardner and David Millington. Completing the trio is Chris Hughes from Assembla.

—

This webinar has concluded. If you missed it,  you can scroll down and watch the replay, skim through the highlights, and access the presentation slide. 

Slides

Webinar replay and summary

Timestamps and Section Summary

• 0:00:00 Introduction and Agenda
  A brief introduction of the presentation’s agenda and what the audience can expect to learn from the presentation.
• 0:04:15 Assembla Feature Highlight
  Learn about what Assembla is, and what powerful features it provides with an explainer from Assembla PM himself. Learn more about Projects, spaces, issues, and the possible integrations available in the platform.
• 0:09:44 Where to Use Assembla
  Setting Assembla with Unreal Engine is the core of this webinar but there are many different possible use cases for it depending on how you set up your workspace and views. It could be an all-encompassing project manager and planner, or it could be an internal help desk ticketing solution. Chris explains the possible setups in detail in this section.
• 00:14:09 Using cloud-hosted Perforce with Assembla
  Apart from providing a cloud-based system, Assembla also provides users access to a support and devtools team ready to assist. Chris provides an explainer.
• 00:15:55 Intro to Cloud-based management and Source Control
  In this section, Chris G. gives a rundown of his part of the webinar. He explains the process of downloading and uploading to cloud-based systems. And he explains that the process remains the same whether it’s source code, or even gigabyte huge assets. If you want to set up your own cloud-based Perforce system for Unreal and don’t know where to start, it would be best to begin here.
• 00:17:40 Source control: Definition and Benefits
  What is source control and what are the following factors to consider when choosing a platform? Learn more about it in this section. Chris also talks about regression, version security, and historical recall in this section.
• 00:21:30 Unreal Engine 5 & Perforce (Helix Core)
  Why does Unreal have specific integration and built-in support for Perforce? What features does Unreal provide that makes this integration easier? Chris talks about the scripting features inside Unreal and how you can set this up to connect to servers and automatically sync changes internally and externally among team members.
• 00:23:18 Partner Shoutout: Visual Assist
  While not directly related to setting up Perforce with Unreal, Visual Assist is something that Unreal Engine developers should have. Get a brief intro to one of the best C++ Visual Studio plugins in this section by the lead developer of the tool himself.
• 00:25:17 Demo Start: Unreal Engine 5 source control
  The main event of the presentation. Chris G. takes us step by step into how to set up Unreal Engine with Assembla—from initializing Perforce, all the way to setting up your first space and first repository, and finally to your first commits.
• 00:25:49 Demo: Adding a repository
  The very first thing you need to do to sync to Assembla is initialize a P4 repository in your space. This section discusses how to set your first repository, find the connecting link on Perforce, and logging in to your Assembla instance.
• 00:27:27 Demo: Create a workspace
  After connecting to Assembla, you will need a place to upload your files and assets to. Chris opens up Perforce and sets the main stream in this part of the demo.
• 00:30:11 Demo: Summary of process
  Few reminders and things to keep in mind before you are all set and ready to go. He also opens the Unreal editor to check if the initialization was successful.
• 00:31:28 Demo: Verifying integration via Unreal Editor
  Check to see if you did the setup correctly by verifying the integration inside the Unreal Editor/Perforce P4. Chris commits a sample change using a blueprint file.
• 00:34:25 Demo: Final checks
  Some other tips and reminders for using other integrations such as Visual Studio plugins and hookups. Afterwards, you just have to share the repository with teammates and everyone should be able to collaborate.
• 00:38:50 Question and Answer
  Here are some of the questions from the Q&A
  – Is Assembla beginner friendly?
  – Does version control work for binaries?
  – Supported languages for security scans?
  – License costs?
  – Perforce client vs Assembla web client?

What’s Next?

Interested in getting started with Assembla and its Perforce integration for game development? Get started by visiting Assembla’s game development web page.

And if you’re using Unreal Engine, give Visual Assist a try. It’s the perfect plugin to pair with Assembla for faster and easier development.

If you have something specific to request for the next webinar, send your feedback to this email.

The post Setting up cloud-hosted Perforce source control for Unreal Engine [Webinar Recap] first appeared on Tomato Soup.

Visual Assist HLSL support

High-level shader language (HLSL), while vaguely similar to C in syntax, is a distinct language and thus most native Visual Studio features may behave differently.

This may bring some frustration, and that’s what VA intends to fix! We’ve had some manual registry edits to let VA work with shaders, but that hasn’t been well-known and we’ve also wanted to improve our internal support before officially supporting the language.

Which is why we’re excited to announce that Visual Assist ‘s features will now work for HLSL, USH and USF files—the latter two being the Unreal Engine-specific shader files.  This includes:

• Code navigation features
• Syntax highlighting 
• Context-aware smart suggestions
• Automatic code generation prompts

Basic HLSL syntax highlighted by Visual Assist.

Please note that support is still in early beta – marking ‘beta’ is standard practice for us for key new features – and that some complex features like refactoring may have some issues. We ask that when you work with HLSL and Visual Assist to send feedback our way to improve behavior.

We often focus on Unreal Engine, where VA is widely used, but HLSL files are used across the graphics industry and this feature is useful for all developers writing shaders, no matter the technology or engine you’re using.

Note: Because it’s in beta, shader file support is disabled by default. To enable it, go to Visual Assist Options ->> Game Development ->> Enable support for shader files

Two new code inspection updates

The first check involves flagging constructors with incomplete initialized fields. Constructors don’t always initialize all fields. And some types don’t have initialization that leaves them in a ‘good’ state – one example is a pointer type. This check flags constructors that leave fields of those types uninitialized.

The second checks for a common mistake when using std::string::compare (or other string types like wstring) method to compare strings. To elaborate, the compare method returns three possible values (instead of a simple boolean True or False) because its primary use is for sorting. If your code is using it where an equality or inequality check would work and be more readable or easier to understand, this check recommends it.

Check for std::string::compare

Access Visual Assist’s code inspections by accessing the following:
(If you are not seeing options, please remember to enable code inspections!)

• Quick Actions and Refactorings menu ( Shift + Alt + Q ) 
• VAssistX ->> Code Inspection (beta) ->> VA Code Inspection Results

New Linux-style navigation in Open File in Solution

Open File in Solution will now accept forward slashes to filter certain directories. Adding a forward slash ( / or \ ) before a string will filter all files not contained in a directory starting with the string. This is a productivity feature: on many keyboards / is easier to type than \, and so several customers requested the forward-slash work. A small feature, but one we think shows our dedication to useful details.

And for those who are unaware, Open File in Solution also accepts the following:

• Negative filtering ( – )
• Multiple entries ( , )
• BeginsWith filter ( .string)
• EndsWith filters ( string. )

You can learn more about available options in the documentation.

Even more

There are several quality fixes as well, since every release we aim to make it better. For more information about the changes in this release, head on over to the documentation.

We hope you find the new inspections and shader support useful, and as always, happy coding!

The post Visual Assist 2022.3 now available first appeared on Tomato Soup.

What are the benefits of using Visual Studio for software development?

Visual Studio is an integrated software development environment that allows you to create console and desktop applications, websites, and web services. Visual Studio for UE4 allows you to easily create beautiful and realistic 3D games.

Visual Studio is a modern and powerful IDE that includes a code editor, a built-in debugger, a form editor for creating an application’s graphical interface, and a web editor. Visual Studio Unreal Engine provides an advanced set of tools for creating modern games.

You can perform application testing, versioning, and deployment to the cloud using features provided by Visual Studio. If you want to extend its functionality you can install additional third-party plugins.

Visual Studio is one of the most used IDEs for C++ software development. Millions of developers from large and small organizations use it.

What is Unreal Engine, and what is it for?

Unreal Engine is a very powerful and popular engine for creating 3D graphics. It is a large system of tools and editors that allows you to create and manipulate 3D objects and scenes.

This modern engine allows you to create games for most modern operating systems and portable devices. It supports various rendering and audio playback systems, text-to-speech tools, speech recognition, modules for working with the network, and various input devices.

You can use Unreal Engine to develop games of various genres. Besides, you can use it for architectural and automotive visualization, linear film and television content creation, broadcast and live event production, training and simulation, and other real-time applications.

How to set up Visual Studio for Unreal Engine?

You can integrate Unreal Engine with Visual Studio, which allows you to easily and quickly make changes to the code and instantly see the results of its work after compilation.

To use Visual Studio together with UE4, first, you need to set up your Visual Studio. In the Visual Studio installer, select Game development with C++ in the Workloads tab. Also, you need to select these additional options: C++ profiling tools, C++ AddressSanitizer, Windows 10 SDK, and Unreal Engine installer. After that, install the selected tools.

Then you should use the Epic Games Launcher, which provides you the ability to install Unreal Engine if it is not already installed on your system.

How to work with Unreal projects in Visual Studio?

To create a new project, use the Unreal editor. You can use Blueprints or C++ code.

When you select C++ code, the Visual Studio solution is generated automatically.

With the Unreal editor, you can open the created project in Visual Studio. To do this, use the menu command File -> Open Visual Studio.

This command will open a Visual Studio solution with two projects. One project is for the Unreal Engine code. The other is your game project code, named the same as your Unreal project. After that, you can edit, build and debug your Unreal game using advanced features provided by Visual Studio.

What are the benefits of Unreal Engine developments in Visual Studio?

Visual Studio is widely used by C++ game developers. It is a proven and one of the most popular code editors. It is the recommended IDE for game development using Unreal Engine.

When developing games using Visual Studio, you can take advantage of the features provided by IntelliSense to significantly speed up the coding process.

Visual Studio also provides an excellent C++ debugger for Unreal Engine, similar to the one used to debug other C++ projects.

There is an UnrealVS extension for Visual Studio Unreal Engine that makes it easy to add launch options and create a lot of configurations at the same time. UnrealVS allows you to set up startup items, create bindable commands for compiling startup projects, set command line parameters, compile projects in batches, quickly compile the project menu, and much more.

Also, Visual Studio provides the ability to install additional C++ extensions to extend its functionality for game development using Unreal Engine. Visual Assist is one of these C++ extensions.

How Visual Assist for Unreal Engine supports developments in Visual Studio?

Visual Assist constantly releases updates and supports all new versions of Unreal Engine. This C++ extension offers advanced features for easier navigation, refactoring, code generation, and much more for your Unreal Engine projects.

Visual Assist provides features that increase developer productivity. You can rename resources with Core Redirect. This is an Unreal feature that keeps track of old and new names to keep code and blueprints that refer to the old name. Visual Assist can add this information when renaming. This feature allows you to rename without having to worry about the game crashing.

When you rename a class, file, method, variable, and any other type or object, all of its uses, including comments, lines, and headers are renamed automatically.

In addition, Visual Assist allows you to quickly type code using smart suggestions for U*Macro specifiers. For newly entered specifiers, Visual Assist quickly finds and displays suggestions.

Visual Assist automatically adds a superclass call to the template when extending the functionality of the engine. This reduces the number of steps you have to perform manually.

With Visual Assist, you can quickly and easily navigate through code and perform refactorings. To do this, use functions such as Goto, find links, rename, and change the signature. The ability to read U*Macro specifiers optimizes these functions.

Visual Assist allows you to speed up the process of studying documentation by displaying comments from base classes for Unreal Engine C++ and U*Macro specifiers in the code. With Visual Assist, you can easily and quickly learn Unreal Engine.

In this article, we looked at the main advantages of developing modern 3D games using the Visual Studio Unreal Engine. Install the Visual Assist C++ extension for Visual Studio with Unreal Engine support and develop exciting games faster and easier.

The post What Is Visual Studio For Unreal Engine, And Why Does It Matter? first appeared on Tomato Soup.

The reason is the growing popularity of video games. The ever-increasing power of modern game engines has also led many people in gaming industries to strive for a more visually impressive and immersive gaming experience.

In this article, we will focus on how successful people make the most of their Unreal Engine with the help of WholeTomato’s Visual Assist.

1. What is Unreal Engine?

Unreal Engine is a video game engine developed by Epic Games. The founder, Tim Sweeney, designed it to help developers create video games for both PC and Mac platforms.

As the product grows, it can now be used by creators across industries. You can use it to create any VR, AR, mobile game, traditional console game, or animated feature film.

The company offers a free version of the software and a subscription-based version that allows you to use its engine on multiple platforms.

Unreal Engine is easy to use because it has Blueprints’ development tools. Blueprints tool helps a beginner game developer, who doesn’t quite master the programming language yet, to create their game from scratch.

The key benefits of using Unreal Engine include:

• You can use Unreal Engine to create games on mobile platforms, consoles, VR, and AR platforms.
• Unreal Engine also allows you to create 3D games.
• Unreal Engine also allows you to use code written in C++ and C#. Even if you’re not familiar with programming, there are many extensions out there that can help you use it.

2. What is Visual Assist?

Visual Assist is a tool that helps you simplify your game development workflow. When paired with Unreal Engine, it helps you work with a slew of efficiency.

It is a plugin for Visual Studio and it is available for all versions of Visual Studio. It is a Visual Studio extension and can make your life easier when working with Unreal Engine. 

You can use it to make the most of your time while working on a project and it will help you save hours of your time by eliminating tedious tasks.

Visual Assist has settings to customize how it works to suit your workflow better.

For example, you can choose to autocomplete U*Macro specifiers or make intelligent suggestions based on what you’re writing.

You can also automatically select which type of return value you want in C++ and C# by making implicit application and validating method aware of all U*Macro specifiers.

3. What Are the Top Features of Visual Assist?

Visual Assist is famous for several of its key features, including:

• Refactoring
• Code Generation
• Coding Assistance
• Code Inspection
• Debug Assistance

Refactoring

The Refactoring feature allows you to refactor your code quickly without losing the source code. Visual Assist makes it easy to rename variables, methods, classes, etc., and instantly shows you what will happen if you apply the change.

Code Generation

Visual Assist is also known for its code generation feature. This feature allows you to auto-generate methods and classes for your code.

You can choose between different code generation methods and define a custom set of rules for generating code.

Visual Assist will then provide a list of methods generated based on your defined rules.

Coding Assistance

The coding assistance feature of Visual Assist offers syntax highlighting, which shows the format of your current program.

It also includes auto-completion, which offers suggestions as you type a method name or variable name.

This feature provides handy functionality in helping to write large programs more quickly.

Code Inspection

The Code Inspection feature of Visual Assist allows you to view any part of your program. It gives instant feedback about what is wrong with the current line or block of code that you are viewing (if any).

The feedback is provided by “understanding” what you are doing. It can guide you to fix the problem on that line or block of code.

Debug Assistance

The Debug Assistance feature of Visual Assist provides an easy way to debug your program. It will show you all methods that have been called and the values they have returned.

This feature allows you to quickly and efficiently track down why your program doesn’t work.

4. How Can You Use Visual Assist to Make The Most Of Unreal Engine?

There are several ways Visual Assist can help you make the most of your career in the games industry.

You can use it to:

a. Remove Annoying Tabs

When you’re working on a project with Visual Assist, you won’t have to worry about creating tabs for every file you work with. Visual Assist will do that for you.

You will only need the tabs when you want to add or edit code. Therefore, this feature is crucial for developers who are new to programming. They’ll be able to focus more on what they’re doing and less on the mundane tasks.

b. Smart Suggestions for U*Macro Specifiers

U*Macro specifiers allow developers who are new to programming to use C++ and C#. With this feature, developers don’t have to enter them manually every time they write code.

Visual Assist automatically selects the best way, such that new developers do not need to think which specifier is which every time they write code.

c. Implicit Application and Validate Method Aware

Implicit application and validate method awareness is another feature that makes it easy for developers who are new to programming. The feature lets them know when they make mistakes in their coding logic and how they can fix those mistakes.

d. Go Without IntelliSense

Visual Assist lets you work without worrying about the type of return value you want to get from a function or method. It will auto-select the best way to write code for you.

Therefore, you don’t need to use IntelliSense in Unreal Engine. In addition, you can remove unnecessary built-in plugins from your software. Finally, creating more space is essential for developers who need more memory and storage.

e. QuickInfo for U*Macro Specifiers

The QuickInfo feature lets you know the specifier of a function or method when you hover over it. This feature is helpful for developers because they can read up on specifiers whenever they need to.

5. Ready to Snatch Success with Visual Assist?

WholeTomato’s Visual Assist is a tool that makes it easy for developers to focus more on their craft and less on coding. So, any game maker can have it easy while working on the next-gen console game and test their creative side.

It’s not a replacement for a dedicated team of programmers, but it can significantly lift developers’ work burden.

To get started with Visual Assist, check out the trial version and the tutorials on our site. Make the most of Unreal Engine now!

The post How Successful People Make The Most of Unreal Engine first appeared on Tomato Soup.

Although Visual Studio is the most extensible IDE on the planet, it cannot cater to all development needs. Game development is one such instance where better support from Visual Studio for Unreal Engine development becomes necessary.

This guide will cover everything relating to the Visual Studio Unreal Engine. It’ll help us link Unreal Engine with Visual Studio. Moreover, we will explain the innovative things happening with Visual Studio Unreal Engine.

What is Unreal Engine?

Unreal Engine is the one of the most potent 3D creation tool and game engines available on the market. It features several components that become the building blocks of a game. 

It is made up of components that work together to drive the game. It has a massive system of tools and editors. The Unreal Engine editor helps game developers to organize their assets and create the gameplay. 

Hence, Unreal Engine is a suite of creation tools for game development and automotive visualization. It also helps with linear film and television content creation and other real-time applications. 

What are 5 Innovative Features of Visual Studio Unreal Engine?

To build applications with unique features, integrating Visual Studio and Unreal Engine is important. Visual Studio works perfectly to turn vision into reality with tailored support for Unreal Engine. If you have already linked both, you can access tailored navigation, refactoring, code generation, etc. 

Additionally, note that Visual Assist is a Visual Studio extension. It offers support for an Unreal Engine. Below, we will take on five innovative features of the Visual Assist Unreal Engine. Developers can leverage these features for optimal performance. 

Here are the five most innovative features of Visual Studio Unreal Engine:

1. Removes Annoying Tabs

Ever wondered how you can turn off macro warnings? Or how to get rid of pop-up tabs? As a game developer, tabs opening is the most annoying thing. It opens whenever a function or class is declared. If you are struggling with the same issue, visual assist Unreal Engine has a solution for you.

With Visual Studio Unreal Engine, this isn’t a problem. Visual assist removes the annoying tabs after U*Macros. So, whenever a developer declares a function or class, it halts the pop-up warning. Plus, it also gives complete autonomy to the developer.

2. Gives Smart Suggestions for U·Macros Specifiers 

Forget annoying pop-ups, but who does not love the intelligent suggestions for macro specifiers? Smart suggestions make your code more productive and fast while giving you control over all the specifiers. You can type specifiers rapidly and with less switching to credentials for most U·Macros. 

If you change the Unreal Engine and add new specifiers, visual assist detects and suggests them. So, you have to worry less about the specifiers and focus more on developing games. 

3. Implicit Application and Validate Method Aware

One amazing feature of visual assist is that it reads U·Macro specifiers. With this feature, all its other features can be made smarter too. 

For instance, visual assist provides features that can find references. It can also rename and change signatures to support implicit methods.

4. No Need for IntelliSense

IntelliSense is a general term used for code editing features. These include code completion, parameter info, member lists, and quick info. All these features help developers learn more about the code. 

However, you do not need IntelliSense anymore as visual assist does all this better. The coding becomes more effortless and devoid of any incorrect red squiggles with the visual assist. It also helps save memory by disabling the built-in tooling. 

5. Shows U·Macro Specifiers With Additional Info

The macro specifier’s additional info helps the game developer better understand the code. For this, visual assist has smart features that show comments from base classes, including the U*Macro specifiers.

The record for Unreal Engine C++ is often in the code itself. It contains the guiding material for all developers.  

The above innovative features are possible only if Unreal Engine is linked with Visual Studio. So, here is how to connect Visual Studio with Unreal Engine. 

How to Link Visual Studio with Unreal Engine?

Unreal Engine (UE) is designed to integrate smoothly with Visual Studio (VS). It enables you to make code changes in your projects quickly and easily. Setting up a Visual Studio Unreal Engine can help improve the overall user experience. 

To integrate, include the Unreal Engine installer when installing Visual Studio. After this, locate the summary sidebar on the right. Expand the game development with the C++ section. Under the ‘optional,’ make sure the checkbox for ‘unreal engine installer’ is enabled. Lastly, click install, and Visual Studio will be linked with Unreal Engine. 

It is worth mentioning that unlocks Unreal Engine’s maximum potential when used with Visual Studio. Visual Studio Unreal Engine is poised to integrate to create great game development projects. 

Want to Increase Your Productivity with an Unreal Engine? Get Visual Assist Today

Visual assist is a C++ extension that turns vision into reality with tailored support for an Unreal Engine. With this, a developer writes code faster and gets code corrections as he makes them. 

It is possible due to the visual assist features. Features like code generation, code understanding, code assistance, and refactoring enhance the developer’s capacity. It also improves virtually every Microsoft IDE with the multitude of Visual Assist features. 

If you have not tried it yet, try Visual Assist for free. It will be fully functional for the next 30 days under the trial period. Once the trial period ends, you can decide whether to keep it or not. If you decide against it, remove it at any time with the IDE extension manager. 

The post The Most Innovative Things Happening With Visual Studio Unreal Engine first appeared on Tomato Soup.

I wanted to send out a few takeaways from our group:

The biggest thing we get out of GDC each year is the direct contact with users. This year was no exception. There’s only so much we can do to create actual dialogue with developers through marketing and GDC is always an opportunity for us to get past that and hear from you. If you stopped by our booth, even briefly in the hustle, and gave feedback, know that our team is already working on ways to integrate that into our dev plans or even our existing roadmap.

The opposite side of this coin is getting in front of people that don’t use us at all or haven’t in a while. This year with Epic and Unreal Engine being absent, there were seemingly many more Unity developers. As you may know, our strength has always been C++ over C#. That’s frankly because of how well Visual Studio handles C# and we show massive gains with C++ (feel free to ask me about our secret sauce). In any case, it was good to chat with a few developers that primarily work with C#, some after years of not using Visual Assist still had good feedback for us around C# tooling.

A final takeaway for me personally was the passion that you have for your tooling. Whether it be things which we provide, native tooling, or other extensions. This passion is pretty contageous as our team walked away a bit refreshed and excited about the future of our tools and the game development space in general.

So what do we do with what we learned?

Much of our action items from GDC is turning your feedback into feature requests or bug reports with our Dev team. But bigger than that we want to open more lines of communication. We’ve started holding focus groups specific to two industries that we see benefits for our tooling (Game Development and Finance). We’d like to take this one step further with the launch of an MVP program. The goal with this is to give a select group of developers inside access to our development team, latest builds, and roadmap, in order to help guide the direction of our efforts in a meaningful way to continue producing great releases that you’re used to. Stay tuned for more info on each of these as we solidify the plans.

Lastly, Special thanks to those who stopped by to discuss our sister companies Embarcadero and UltraEdit. If you’ve been a developer for a while, Rad Studio and Delphi may have been one of your first IDEs and languages. Check out the awesome things we’re doing over at Embarcadero.com. And for those of you that want to use a text editor that’s got some enterprise stability and security check out UltraEdit!

Thanks for having us at GDC. Hope to see you again next year!

The post GDC You Next Year! first appeared on Tomato Soup.

In this blog, we’ll talk about a few things you might want to know before you get started in the video game industry. 

The video game industry— by the numbers

Many new programmers aspire to land careers in the video game industry. Who wouldn’t want to make triple-A games for a living, right?

In fact, the video game industry has been rising for years now, fueled by more and more players and indie gaming studios. This trend has brought unprecedented growth year after year, both in the number of users and in the quality of games.

It’s no wonder that many new developers—many of whom were gamers themselves at some point—try to get into the game industry.

Things to consider before deciding on a career as a game developer

Before finalizing a career choice in game development, there are a few things you have to consider first. Most people miss one key thing—playing games is an entirely different arena from creating one. 

A career in game development involves investing a lot of time in practicing and learning (months and years even) and then more hours of actual work and debugging.

Game development is like producing an indie film. The goal is relatively simple to visualize, but as soon as you start doing it, you find that there are a lot of hidden elements and complexities like finding actors, sourcing equipment, or writing a script, among other things.

However, if you can look past the apparent startup hurdles (which are present in any career or hobby), then you can start practicing your skills and be on your way to becoming a full-time game developer.  

Here are a few other questions to ask before deciding on a career in game development: 

• What programming languages will you use?
• Are you more of a game artist or a game programmer?
• How much time and resources are you willing to invest in learning?
• Are you doing this as a recreational hobby or to build your resume?

Tip #1: Start with simple projects

One of the best ways to start is by getting some hands-on experience by completing a project from start to finish. You can start with something simple, like a game of Pong or a side scroller using the language of your choice. 

But don’t let the “beginner” tag fool you!  

You will find that even the most simple of games require a lot of time and effort to create. However, creating a game from scratch will serve as a great introduction to the hidden complexities of game development, such as:

• Creating objects
• Programming player input and controls 
• Adding simple AI for NPCs
• Object physics
• Game conditions and objectives
• Game UI and menus

You can also find completed projects from other developers to use as a benchmark for your own projects.  For example, this Pong source code is available on GitHub and is open for the whole community to examine, copy, modify, experiment with, and more.

And if you get stuck on something, don’t be afraid to ask on gamedev forums such as Reddit or Stack Exchange. You would be surprised by the number of people who would be willing to help. 

There are also tutorials on YouTube if you prefer videos. Full-fledged courses, both paid and free, are also available on popular providers such as Coursera or Udemy.  You just have to look for the one that fits your learning style the best. 

When you finish your first game, remember that it doesn’t have to be super polished or bug-free. The important thing here is to experience game development and all things related.

Tip #2: Build upon pre existing resources with game engines

If you’re feeling a bit more adventurous, you can try a different approach by using game engines like Unity or Unreal Engine. 

The main advantage of using game engines is access to pre programmed templates and assets. In fact, many new developers go this route so they can focus on game design and avoid many of the technical (and often tedious) details for later.

For example, something basic like drawing text using Direct X code is several degrees more complex than using a built-in GUI in Unity or Unreal. These instances tend to frustrate beginners and steer them away from ever finishing their first game.  

Another advantage of using these big game engines will give you access to a very active community of other developers as well as some very useful documentation.

• Unreal Engine Documentation
• Unity Documentation

For instance, you can head over to Unreal Engine’s starter projects for a list of “simplified gaming experiences,” which allow you to try a design approach for a specific game type.

Tip #3: Maximize the tools you are using

This may seem obvious, but you need to familiarize yourself with the tools you are using. Whether you are focusing on graphic design with game engines or coding complicated game mechanics, a certain level of mastery will greatly improve your workflow.

If you are coding in C++, we recommend using a dedicated coding environment IDE like Visual Studio as it’s free and natively supports the language.

Then when at some point you feel that the coding environment you are using is limiting you, it may be prudent to install productivity plugins like Visual Assist. This will greatly help with navigating, managing, and writing huge code projects (which is almost always the case with game development projects). It also has dedicated features and support for Unreal Engine.

In summary

Here’s a quick recap on how you can get started with your game development career.

• Understand that playing games is different from programming them
• Determine how much time and effort you can allocate to learning
• Start with simple projects to build experience
• Utilize all the resources available 
• Maximize your efficiency with the right tools

Always remember that there is no clear-cut path to becoming a game developer. There are people who start as solo hobbyists, while some were recruited due to their experience in similar fields. But what you can do is pick a project you like, and keep practicing until you reach your goal!

Bonus tip: Watch how other game developers work

Trying to understand how to program games through a blog article can take you only so far. Try to find more experienced developers and see how to integrate some of their best practices and habits into your workflow.  

And as an alternative, you can register for Whole Tomato’s webinar on ways to improve game development experience. This short webinar will showcase how to do simple projects in Unreal Engine.

The post Tips for Aspiring Game Developers first appeared on Tomato Soup.

While we’ve always announced features in our changelog and release blogs, we’re starting to blog in greater detail about some of what we change — our December blog about reducing memory usage started this — and this time we’ll dig a bit more into two changes improving using Unreal Engine with Visual Assist.

This applies only to versions 2021.1 and 2021.2, the first two versions this year. If you’re reading from the future, there’s likely much more for UE than is described here!

There are two notable items in these versions:

• Improving parse times for Unreal Engine projects
• Removing unwanted generated headers and symbols

These mean that your Unreal Engine projects should be fully usable with Visual Assist faster when you open them, and that Visual Assist only shows and uses methods and other symbols that you’re really interested in.

Parse Times

When a solution is opened in Visual Studio, Visual Assist (VAX) parses that solution. This generates the databases of symbols and other data which VAX uses to be able to implement features like GoTo Related, extra syntax highlighting, parameter info, and so forth.

Parsing can take time. Although VAX is not based around a C++ compiler (one of its strengths), parsing is analogous to compiling a project, and while you can use VAX right away, some features require that data before they will work. Unreal Engine solutions can be very large. Therefore, we spend a lot of thought on how to speed up parse time to make the time between opening a solution and having VAX fully functional be as short as possible.

Avoiding Unnecessary Parsing

This following is going to sound ridiculously simple, and it is. What’s the best way to spend less time doing something? Not to do it.

We do focus on optimisations; the parse engine is heavily multi-threaded; the database uses considerably less memory than it used to; and other techniques. But ultimately, the best way to reduce parse time is to do less parsing.

Unreal Engine projects include plugins. These are additional libraries that add features to your game or project (in-editor or at runtime.) The UE editor lets you enable and disable these, so it’s common to have several installed but only use a subset of them. Yet, the presence of plugins is a key item that makes parsing a UE project lengthier. We added an option to turn off parsing them.

In 2021.1 we added an option to disable indexing these plugins. When off, the default, UE plugins were not parsed.

However, we realised this was based on a flawed understanding: that if plugins are third-party (as plugins often are) then you may not need them to be parsed into VAX’s memory: after all, we thought, you’re unlikely to do a ‘find references’ on an internal method of a third-party library. Omitting them from being parsed would not affect day to day use of Visual Assist. But we got feedback that it was more common than we thought for plugins to be first-party: that is, for UE developers to move parts of their game or project’s functionality into a plugin. That means that it was necessary to parse some plugins, and so a simple on/off parse all-or-none toggle was not useful.

In 2021.2 we expanded the setting so that Visual Assist can parse plugins that are genuinely used by your project, only. Today the ‘Index Unreal Engine plugins’ setting has three options for parsing plugins:

• None: don’t parse anything in the Plugins folder. This reduces parse time the most
• Referenced: parse only plugins references by the project, and referenced by default. Depending on how many plugins you have installed that are not used, this still reduces parse time. It is the recommended setting
• All: parse all plugins; there is no reduction in parse time.

Real-World Performance Improvements

The amount of time saved by not parsing unused plugins depends on the complexity of your Unreal Engine solution and the specific machine on which Visual Studio runs, but some real-world measurements are as follows:

The absolute values may vary but we expect the relative percentage to be broadly applicable.

Notes

If you open a file from a plugin folder which was not parsed (either not referenced, or the above setting was set to None), then you will see a notification message that the file was not parsed and Visual Assist won’t provide your expected functionality for that file. This is shown only once, and won’t be shown again until Visual Studio restarts.

Avoiding Parsing UE-Generated Files

Saving a very useful change for last — there are many places Visual Assist shows you the symbols and files it’s aware of. The two main windows are Open File In Solution which lists all headers (and other files), and Find Symbol will list every symbol in the database. Unreal Engine, however, generates header files, and these include generated symbols, neither of which are useful in practice when coding on your UE project in Visual Studio.

Voila, a new setting, which means Visual Assist won’t show *.generated.h files, and the Find Symbol dialog is not polluted with generated symbols either. The setting is called ‘Index generated code’ and is off by default. That is, the default is aimed at clean results within Visual Assist, to not index these generated files and store those generated symbols. You can always turn it back on if you want the old behaviour.

Unreal Engine with Visual Assist 2021.1 and 2021.2

The above covers only the first two releases this year, and we have more planned. However, the parsing speed improvements (including our followup for more granular parsing of plugins) and removing generated files and symbols by default should the general ‘quality of life’ using Visual Assist with Unreal Engine. As always, feedback is welcome!

The post Unreal Engine ‘Quality Of Life’ in Visual Assist 2021.2 first appeared on Tomato Soup.

Written by David Millington (Product Manager), Goran Mitrovic (Senior Software Engineer) and Christopher Gardner (Engineering Lead)

Visual Assist is an extension which lives inside Visual Studio, and Visual Studio is a 32-bit process, meaning that its address space, even on a modern 64-bit version of Windows, is limited to a maximum of 4GB. Today 4GB doesn’t always go very far. A typical game developer, for example, may have a large solution, plus perhaps the Xbox and Playstation SDKs, plus other tools – already using a lot of memory – plus Visual Assist. A lot of Visual Assist is built around analysis of your solution, and that requires storing data about your source code, what we call the symbol database. Sometimes, with all of these things squashed into one process’ memory space together, some users with large and complex projects start running out of memory.

The latest version of Visual Assist (build 2393, 28 Oct 2020) reduces in-process memory consumption significantly. It’s a change we think will help many of you who are reading this, because those with large solutions who run into memory issues should find those memory issues alleviated or disappearing completely; and those with small or medium solutions may find Visual Assist runs a little faster.

Plus, it’s just part of being a good member of the Visual Studio ecosystem: as an extension relied on by thousands of developers, yet sitting in the same shared process as other tools, we should have as little impact as we can.

The chart above shows that the new build of Visual Assist reduces VA’s memory usage by about 50% – that is, half as much memory is used. You can see more charts below, and we consistently see 30%, 40% and 50% memory savings.

We’d like to share some technical information about the approaches we took to achieve this, and we hope that as C++ or Windows developers you’ll find the work interesting. This is a fairly long blog, and starts off light and gets more technical as it goes on. It covers:

• Concepts
• Background – Where Visual Assist Uses Memory
• String Storage Optimizations
• Moving Out Of Process: Entire Parser
• Moving Just Memory
• Chunk / Block Structure and Allocation / Freeing
• Optimizations
• Results

Concepts

Many readers may know this, but to follow this post here’s a quick primer on some concepts. Feel free to skip to the next section if you’re already familiar.

Address space refers to the total amount of memory an application can use. It’s usually limited by the size of a pointer (because a pointer points to memory): a 32-bit pointer can address 2³² (about 4 billion) bytes, which is 4GB. So we say that a 32-bit process has a 32-bit address space, or an address space of 4GB. (This is hand-wavy – although true, on 32-bit versions of Windows this 4GB was split between kernel and user mode, and a normal app can only access usermode memory; depending on settings, this actually meant your app could access only 2GB or 3GB of memory before it could not allocate any more. On a 64-bit version of Windows, a 32-bit app has the entire 4GB available. Plus, there are techniques to access more memory than this even on 32-bit systems, which is getting ahead of where this blog post is going.)

This address space is a virtual address space; the application uses virtual memory. This means that the 4GB is not actually a sequential block of memory in RAM. Pieces of it can be stored anywhere, including on disk (swapped out) and loaded in when needed. The operating system looks after mapping the logical address, the address your application uses, to the actual location in RAM. This is important because it means that any address you use has what backs it, where it actually points to, under Window’s control.

A process is how your application is represented by the operating system: it is what has the virtual address space above, and contains one or more threads which are the code that runs. It is isolated from other processes, both in permissions and memory addresses: that is, two processes do not share the same memory address space.

If you’re really familiar with those concepts, we hope you’ll forgive us for such a short introduction. OS architecture including processes, threads, virtual memory etc is a fascinating topic.

Background – Where Visual Assist Uses Memory

Visual Assist parses your solution and creates what we call the ‘symbol database’, which is what’s used for almost every operation – find references, refactoring, our syntax highlighting (which understands where symbols are introduced), generating code, etc. The database is very string-heavy. It stores the names of all your symbols: classes, variables and so forth. While relationships between symbols can be stored with relatively little memory, strings themselves take up a lot of space in memory.

Our first work on memory optimization focused on the relationships, the links between data, and metadata stored for each symbol, and we did indeed reduce the memory they used. But that left a large amount of memory used by strings generated from source code. In addition our string allocation patterns meant strings were not removed from memory when memory became full and there was allocation pressure, but instead at predefined points in code, and that also increased the risk for large projects of getting out of memory errors.

Clearly we needed to solve string memory usage.

We researched and prototyped several different solutions.

String Storage Optimizations

Stepping back in time a little, string memory usage is obviously not a new problem. Over time, Visual Assist has used several techniques to handle string storage. While there are many possible approaches, here’s an overview of three, one of which Visual Assist used and two of which it has never used, presented in case they are new or interesting to you.

String interning addresses when there are many copies of the same string in memory. For example, while Visual Assist has no need to store the word “class”, you can imagine that in C++ code “class” is repeated many times throughout any solution. Instead of storing it many times, store it once, usually looked up by a hash, and each place that refers to the string has a reference to the same single copy. (The model is to give a string to the interning code, and get back a reference to a string.) Visual Assist used to use string interning, but no longer: reference counting was an overhead, and today the amount of memory is not an issue itself, only the amount of memory used inside the Visual Studio process.

While we’re discussing strings, here are two other techniques that are not useful for us but may be useful for you:

• To compress strings. Visual Assist never used this technique: decompression takes CPU cycles, and strings are used a lot so this would occur often.
• To make use of common substrings in other strings: when a string contains another string, you can refer to that substring to save memory. A first cut might use substrings or string views. This is not useful for us due to the overhead of searching for substrings, which would be a significant slowdown, and the nature of the strings Visual Assist processes not leading to enough duplication of substrings to make it worthwhile. A more realistic option (in terms of performance, such as insertion) for sharing string data than shared substrings would be to share data via prefix, such as storing strings in tries. However, due to the nature of the strings in C++ codebases, our analysis shows this is not a valuable approach for us.

The approach we took to the recent work was not to focus on further optimising string storage, but to move where the string storage was located completely.

Moving Out Of Process: Entire Parser

Visual Assist is loaded into Visual Studio as a DLL. The obvious approach to reducing memory pressure in a 32-bit process is to move the memory – and whatever uses it – out of process, which is a phrase used to mean splitting your app up into multiple separate processes. Multi-process architectures are fairly common today. Browsers use multiple processes for security. Visual Studio Code hosts extensions in a helper process, or provides code completion through a separate process.

As noted in the primer above, a second process has its own address space, so if we split Visual Assist into two, even if the second was still a 32-bit process it could double the memory available to both in total. (Actually, more than double: the Visual Studio process where Visual Assist lives has memory used by many things; the second process would be 100% Visual Assist only. Also, once out of Visual Studio, we could make that second process 64-bit, ie it could use almost as much memory as it wanted.) Multi-process architectures can’t share memory directly (again hand-wavy, there are ways to read or write another process’s memory, or ways to share memory, but that’s too much for this blog); generally in a multi-process architecture the processes communicate via inter-process communication (IPC), such as sockets or named pipes, which form a channel where data is sent and received.

There were two ways to do this. The first is to move most of the Visual Assist logic out to a second process, with just a thin layer living inside Visual Studio. The second is just to move the memory-intensive areas. While the first is of interest, Visual Assist has very tight integration with Visual Studio – things like drawing in the editor, for example. It’s not trivial to split this and keep good performance. We focused instead on having only the parser or database in the second process.

Prototyping the parser and database in a second process, communicating with IPC back to the Visual Studio process, showed two problems:

• Very large code changes, since symbols are accessed in many places
• Performance problems. Serializing or marshalling data had an impact. Every release, we want VA to be at least the same speed, but preferably faster; any solution with a performance impact was not a solution at all

Moving Just Memory

Multi-process is not a required technique, just one approach. The goal is simply to reduce the memory usage in the Visual Studio process and move the memory elsewhere; we don’t have to do that by moving the memory to another process—and this is a key insight. While multiprocess is a fashionable technique today, it’s not the only one for the goal. Windows provides other tools, and the one we landed on is a memory mapped file.

In the primer above, we noted that virtual memory maps an address to another location. Memory-mapped files are a way to map a portion of your address space to something else – despite the name, and that it’s backed by a file, it may not be located on disk. The operating system can actually store that data in memory or a pagefile. That data or file can be any size; the only thing restricted is your view of it: because of the 32-bit size of your address space, if the mapped file is very large you can only see a portion of it at once. That is, a memory mapped file is a technique for making a portion of your address space be a view onto a larger set of data than can fit in your address space, and you can move that view or views so, although doing so piece by piece, ultimately a 32-bit process can read and write more data than fits in a 32-bit address space.

Benchmarking showed memory mapped files were significantly faster than an approach using any form of IPC.

The release notes for this build of Visual Assist referred to moving memory ‘out of process’. Normally that means to a second process. Here, we use the term to refer to accessing memory through a file mapping, that is, accessing memory stored by the OS, and potentially more memory than can fit in the process’ address space. Referring to it as out of process is in some ways a holdover from when the work was planned, because we had initially thought we would need multiple processes. But it’s an accurate term: after all, the memory is not in our process in a normal alloc/free sense; it’s an OS-managed (therefore out of process) resource into which our process has a view.

Note re ‘memory mapped files were significantly faster than … using any form of IPC’: sharing memory mapped files can be a form of IPC as well – you can create the mapped file in one process, open in another, and share data. However, we had no need to move logic to another process – just memory.

Chunk / Block Structure and Allocation / Freeing

We already mentioned that the data we stored in the memory mapped file is strings only. In-process, we have a database with metadata fields; in the mapped view are all strings. As you can imagine any tool that processes source code uses strings heavily; therefore, there are many areas in that mapped memory we want to access at or near-at once.

Our implementation uses many file mappings to read and write many areas at once. To reduce the number, each is a fixed size of 2MB. Every one of these 2MB chunks is a fixed heap, with blocks of a fixed size. These are stored in lists:

• 2MB chunks that are mapped, and locked as they are being used to read or write data
• Chunks that are mapped, but unused at the moment (this works like a most recently used cache, and saves the overhead of re-mapping)
• Chunks that are not mapped
• Chunks that are empty

Most C++ symbols fit within 256 bytes (note, of course, this is not always the case – something like Boost is famous for causing very long symbol names.) This means most chunks are subdivided into blocks 256 bytes long. To allocate or free is to mark one of these blocks as used or unused, which can be done by setting a single bit. Therefore, per two-megabyte chunk, one kilobyte of memory is enough to represent one bit per block and to allocate or deallocate blocks within a chunk. To find a free block, we can scan 32bits at a time in a single instruction, BitScanForward, which is handily an intrinsic in Visual C++.

This means that Visual Assist’s database now always has a 40MB impact on the Visual Studio memory space—twenty 2MB chunks are always mapped—plus a variable amount of memory often due to intermediate work, such as finding references, which can be seen in the charts below and which even in our most extreme stress test topped out at a couple of hundred megabytes. We think this is very low impact given the whole 4GB memory space, and given Visual Assist’s functionality.

Optimizations

There are a number of optimizations we introduced this release, including improvements for speedily parsing and resolving the type of type deduction / ‘auto’ variables, changes in symbol lookup, optimisations around template handling, and others – some of which we can’t discuss. I’d love to write about these but they verge into territory we keep confidential about how our technology works. We can say that things like deducing types, or template specialisation, are faster.

However we can mention some optimizations that aren’t specific to our approach.

The best fast string access code is code that never accesses strings at all. We hash strings and use that for string comparison (this is not new, but something Visual Assist has done for a long time.) Often it is not necessary to access a string in memory.

Interestingly, we find in very large codebases with many symbols (millions) that hash collisions are a significant problem. This is surprising because hash algorithms usually are good at avoiding collisions, and the reason is that we use an older algorithm, and one with a hash value only 32 bits wide. We plan to change algorithms in future.

We also have a number of other optimizations: for example, a very common operation is to look up the ancestor classes of a class, often resolving symbols on the way, and we have a cache for the results of these lookups. Similarly, we reviewed all database lookups for areas where we can detect ahead of time a lookup does not need to be done.

Our code is heavily multi-threaded, and needs to be performant, avoid deadlocks, and avoid contention. Code is carefully locked for minimal locking, both in time (duration) and scope (to prevent locking a resource that is not required to be locked, ie, fine-grained locking.) This has to be done very carefully to avoid deadlocks and we spent significant time analysing the codebase and architecture.

In contrast we also reduced our use of threads. In the past we would often create a new thread to handle a request, such as to look up symbol information. Creating a thread has a lot of overhead. Now, we much more aggressively re-use threads and often use Visual C++’s parallel invocation and thread pool (the concurrency runtime); the performance of blocking an information request until a thread is available to process it is usually less than creating a thread to process it.

Symbols are protected by custom read-write locks, which is written entirely in userspace to avoid the overhead of kernel locking primitives. This lock is custom written by us, and is based around a semaphore which we find provides good performance.

Results

All these changes were done with careful profiling and measurement at each stage, testing with several C++ projects. These included projects with 2 million symbols, 3 million symbols, and 6 million symbols.

The end result is the following:

• For very large projects – we’re talking games, operating systems, etc – you will see:
  • 50% less memory usage between low/high peaks doing operations such as Find References (average memory usage difference is less once the operation is complete; this is measured during the work and so during memory access.)
  • Identical performance to earlier versions of Visual Assist
• For smaller projects:
  • Memory usage is reduced, though for a smaller project the effect is not so noticeable or important. But:
  • Improved performance compared to earlier versions of Visual Assist

In other words, something for everyone: you either get far less memory pressure in Visual Studio, with the same performance, or if memory was not an issue for you then you get even faster Visual Assist results.

Here are the results we see. We’re measuring the memory usage in megabytes after the initial parse of a project, and then after doing work with that project’s data—here, doing a Find References, which is a good test of symbol database work. Memory usage here is ascribed to Visual Assist; the total memory usage in the Visual Studio process is often higher (for example, Visual Studio might use 2GB of memory with a project loaded between itself and every other extension, but we focus here on the memory used by Visual Assist’s database and processing.)

One good test project is Unreal Engine:

Another excellent large C++ codebase is Qt:

Our feedback has been very positive: we often work with customers with very large codebases and significant memory usage from many sources inside Visual C++, and the lower impact of Visual Assist has made a noticeable difference. That’s our goal: be useful, and be low-impact.

We hope you’ve enjoyed reading this deep dive into the changes we made in Visual Assist build 2393. Our audience is you – developers – and we hope you’ve been interested to get some insight into the internals of a tool you use. While as the product manager I get to have my name on the post, it’s not fair because I did nothing: the credit goes to the engineers who build Visual Assist, especially Goran Mitrovic and Sean Echevarria who were engineers developing this work, and Chris Gardner our team lead, all of whom helped write this blog post.

A build of VA with the changes described in this post is available for download now, including trying it for free if you’d like. If you’re new to VA, read the quick start or browse our feature list: our aim is not to have the longest feature list but instead to provide everything you need, and nothing you don’t. We also do so with minimal UI – VA sits very much in the background. Our aim is to interrupt or distract you as little as possible while being there when you need it. You can see the kind of engineering we put into VA. It’s built by developers for developers.

The post Technical Deep Dive: Reducing Memory Consumption in Visual Assist build 2393 first appeared on Tomato Soup.