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.

C++ has never been afraid of complexity—but even for a language known for performance and control, the #include system has seemed like a bygone from another era.
Modules in C++ were a long-awaited upgrade aimed at cleaning up the mess of includes, speeding up build time, and making large-scale C++ development a bit less painful.

Standardized in C++20 and expanded in C++23, modules promise big gains in compile times. But as of 2025, they’re still not as widely adopted in most teams’ toolchains. Some developers are diving in and seeing real benefits. Others are holding back, citing spotty compiler support, tricky build integration, and the reluctant to face the learning curve that comes with any paradigm shift.

This post isn’t about selling you on the latest trend or convention—it’s a practical look at what C++ modules actually offer today, where the limitations still lie, and which cases it makes sense to adopt them. Decide for yourself later on.

A Quick Primer on C++ Modules

If you’ve worked with C++ for more than five minutes, you’ve dealt with header files. They’re powerful, but can also add noise: full of macros, guard clauses, and redundant includes that slow down compilation and make dependency tracking a chore. Modules were introduced in order to alleviate some of these issues.

At a high level, C++ modules replace the traditional preprocessor-based #include model with a cleaner, more structured system. Instead of copy-pasting code into translation units, modules compile once, then import—reducing repeated parsing and giving compilers more context to optimize builds.

How C++ Modules Work

A module interface is a standalone file—usually with the .ixx extension—that declares what’s available to other parts of your program. You can then import this module in other files using the import keyword (just like how it works Python), bypassing the need for header files entirely.
Behind the scenes, the compiler builds and caches the module interface, so future builds can skip reprocessing its contents—saving time and keeping things tidy.

Timeline at a Glance

• C++20, officially published in December 2020, introduced official module support, though early compiler implementations were partial.
  
• C++23, released in February 2023, expanded the spec, offering better support for features like module partitions and header unit compatibility.
• Toolchains like Clang, MSVC, and GCC continue to evolve their support—but as of 2025, full interoperability is still a work in progress.

C++ module adoption timeline

Arguments for Adopting C++ Modules

If you’ve ever watched a massive C++ project crawl through compilation—or spent hours untangling a web of includes and macros—then the case for modules probably sounds pretty appealing. Here’s where they shine.

Improved Build Times and Scalability

Traditional C++ compiles every translation unit independently, parsing the same headers repeatedly across your codebase. That’s a lot of duplicated effort.
With modules, compilers can parse once and cache the results (just like how Visual Assist does it!). Module interfaces are precompiled and reused, cutting down redundant parsing.
On large projects, this can lead to significant reductions in full build and incremental compile times, especially when combined with modern build systems that understand modules.
This isn’t just theoretical—early adopters have seen real gains when porting to modules, particularly in libraries with thousands of files and deep dependency chains.

Cleaner Dependencies

Modules bring much-needed structure to C++. They reduce reliance on preprocessor directives and eliminate include guards, forward declarations, and subtle header-only bugs. In fact, they encourage you to think more clearly about what should be exposed and what should stay private.
Since you explicitly export only what’s needed, modules help enforce encapsulation, making APIs easier to maintain and less prone to unexpected breakage.

Improved IDE and Tooling Support

While not all editors are fully up to speed yet, modern IDEs and compilers are catching up. Visual Studio, Clang-based tools, and even some lightweight editors are beginning to provide meaningful module-aware features—like faster IntelliSense, smarter indexing, and fewer false-positive diagnostics.
Once your toolchain supports modules well, you’ll notice a smoother developer experience, particularly when working in large codebases.

Modernization and Future-Proofing

Adopting modules isn’t just about shaving off build minutes—it’s about aligning with the future direction of the language. As more modern C++ features lean into modules (like std::mdspan in C++23), developers who adopt early will be better positioned to take advantage of new capabilities.
Modules are also a gateway to cleaner build systems, more granular dependency management, and even more secure code, thanks to their ability to restrict symbol visibility and reduce accidental API exposure.

Industry Trends and Early Adoption

While modules haven’t reached critical mass yet, they are gaining traction. Library developers and performance-focused teams are leading the way, especially those building SDKs, game engines, or systems software where build time is a bottleneck.
We’ve also seen big names like Microsoft experiment with module adoption in parts of their standard library implementation, and some open-source projects have already migrated small parts of their code to test the waters.

Why you may want to delay adopting C++ Modules (for now)

For all the promise that C++ modules bring, real-world adoption is still, well… cautious. Developers aren’t exactly lining up to refactor their entire codebase just yet — and there are good reasons why.

Not much incentive to adopt

Even in greenfield projects, introducing modules comes with a learning curve. But in legacy codebases? Migration can be daunting. You’ll need to rethink your header structure, untangle tight coupling, and manage new build system dependencies — not to mention retraining your team. And then there’s the question of compatibility: modules don’t play nicely with everything, particularly if you rely heavily on macros, conditional compilation, or platform-specific headers.

In other words, this isn’t a weekend refactor — and for many teams, the payoff doesn’t yet outweigh the cost and it would make more sense to use modules on new projects instead.

Tooling Inconsistencies and Fragmentation

Ask any developer who’s attempted to go modular: Which compiler are you using? matters more than it should. While support for modules exists in Clang, MSVC, and GCC, it’s not uniform — and version-specific quirks can introduce frustrating inconsistencies.

Build system support is also in flux. While CMake has added module support, it still feels experimental, especially for complex project setups or cross-platform builds. Other systems like Bazel or custom build pipelines require more glue code than most teams want to maintain.
In short: the tooling isn’t fully there yet — especially if you’re not using the absolute latest compiler versions.

Lack of Ecosystem Maturity

Even if your toolchain is up to date, the broader ecosystem might not be. Most third-party libraries aren’t shipping with module interface units, which means you’re either stuck writing your own wrappers or falling back to #include anyway. That limits the benefits of going modular in mixed environments — which, let’s face it, is most environments. Until popular libraries (Boost, Qt, etc.) begin offering reliable module support, most teams can’t go all-in without making sacrifices.

Limited Real-World Case Studies

There’s still a lack of detailed success stories when it comes to large-scale adoption. Some early adopters have shared benchmarks or migration notes, but most real-world examples are small experiments, not full production shifts.

Without broader case studies to learn from, many teams are taking a “wait and see” approach — watching how others fare before diving in themselves.

Stability Concerns

The C++ modules ecosystem is still evolving. Compiler behavior can change between minor versions, module-related bugs pop up in tooling updates, and build system support continues to shift.

This kind of churn makes it hard to commit to modules in production, especially in enterprise environments where stability is everything.

Situations Where Modules Might (or Might Not) Be Worth It

C++ modules aren’t an all-or-nothing deal — and thankfully, you don’t have to rip out every #include to start using them. Depending on your project, team size, and tooling setup, modules might either be a smart optimization or an unnecessary complexity. Let’s break it down.

 When Modules Make Sense

• You’re starting a new codebase (especially at scale)
  Greenfield projects are the perfect playground for modern C++. If you’re building a large system from scratch, modules let you start clean — without legacy header baggage. Organizing your code as modular interfaces from the beginning can make maintenance, scalability, and onboarding much easier.
• You maintain a modern toolchain
  If your team is already using the latest versions of GCC, Clang, or MSVC — and you’re comfortable updating your toolchain regularly — you’re in a better position to benefit from the improved compile times and structure that modules offer.
• You’re building reusable libraries
  Modules are a natural fit for API design. If you’re developing shared components, SDKs, or internal packages, defining module interfaces can help enforce encapsulation and create cleaner, more predictable dependencies.
• You have a strong DevOps/infrastructure team
  Getting modules to play nicely with CMake or your CI pipeline isn’t always straightforward. Teams with dedicated infrastructure support can manage the learning curve more effectively and are better equipped to deal with compiler quirks or build system tweaks.

When You Might Want to Hold Off

• You’re working with a legacy codebase
  Old code doesn’t like change. Migrating headers, untangling circular dependencies, and retrofitting module maps can eat up time with little visible payoff — especially if you’re also juggling deadlines.
• Your build system isn’t ready
  If your project relies on complex or deeply customized builds, introducing modules can introduce instability rather than speed. Even popular tools like CMake are still maturing their module support, and not all workflows are smooth yet.
• You rely heavily on third-party libraries
  Until widely used libraries start shipping module interface units, your modules will live in an awkward coexistence with #include. This kind of hybrid environment can be frustrating and lead to confusing bugs or duplicated efforts.
• Your team is small or early-stage
  If you’re moving fast and shipping often, taking time to restructure code for modules might not be worth the effort right now. Simplicity usually wins in the early days — and headers still work just fine.
• Community Perspectives and Industry Signals
  While C++ modules continue to mature, much of their momentum—and hesitation—comes from the wider community: compiler vendors, standards committees, open-source maintainers, and developers who’ve dipped their toes in and reported back. Let’s explore what the broader C++ ecosystem is saying about modules in 2025.

Summary: Key Considerations Before Making a Choice

As we wrap up, let’s briefly recap the main points and outline what you should consider before diving into C++ modules:

Pros of Adopting C++ Modules

• Improved build times: If you’re working with large codebases, the performance gains from reduced redundant parsing can be significant.
  
• Cleaner dependencies: Modules eliminate many of the headaches associated with header file inclusion, such as tangled macros and circular dependencies.
  
• Tooling support: While still evolving, most major compilers (MSVC, Clang, GCC) are heading in the right direction, and IDE support is growing.

Cons of Adopting C++ Modules

• Fragmented tooling: Support across compilers and build systems is still inconsistent. If you’re using a particular toolchain, check for full compatibility before diving in.
  
• Migration cost: Moving an existing project to modules involves significant changes in build systems, dependencies, and possibly code itself.
  
• Lack of third-party support: If your project relies heavily on external libraries, check whether they support modules, or be prepared for some custom workarounds.
  
• Limited case studies: The adoption rate of modules, especially in large-scale real-world projects, is still low, meaning the learning curve could be steeper than expected.

When Should You Adopt C++ Modules?

• New codebases or projects: If you’re starting fresh or adding new features to a project, adopting modules early could save you time in the long run.
  
• Open-source libraries: If you’re maintaining a widely-used library, moving to modules could lead to performance improvements that benefit the community.
  
• Legacy codebases: If you’re dealing with a large, established project, the effort to migrate to modules may not be justified unless you have the resources to support it.

Ultimately, adopting C++ modules in 2025 depends on your project’s size, complexity, and long-term goals. It may be worth experimenting with modules on smaller, isolated parts of your project to gauge their potential before committing to a full-scale migration.

Add more support for modules in C++

If you’re on the fence about using C++ because of the relatively limited tooling available for it, consider adding the Visual Assist plugin for Visual Studio. In a recent update, it added recognition when declaring new modules into your project. This added support makes C++ modules easier to work with with the navigation and auto suggest features working as you’d expect.

The post C++ Modules: What it promises and reasons to remain skeptical first appeared on Tomato Soup.

Think about this. Have you ever thought about two things at once? If you reflect a bit, our brains are super complex but they only focus on one train of thought. Sure, a lot can happen subconsciously, but you can only be conscious about a single thing—you can’t focus on two things at once simultaneously.

But what if you could? This opens up a wide array of possibilities. Imagine learning from multiple sources, or solving three math equations in your head simultaneously, or literally multitasking with each hand doing something different.

That’s the idea behind how graphics processing units (GPUs) are being utilized to fast track development time for a few specialized technologies. With its capability to process significantly more threads (vs CPUs), they can execute tasks that require heavy parallel processing, such as rendering graphics, training machine learning models, and running complex simulations.

And one of the ways to program your GPUs to spit out data that isn’t just graphics is via a framework called CUDA. And that’s what we’re talking about in this blog today.

Why is CUDA being used now

CUDA, which stands for Compute Unified Device Architecture, speeds up computing tasks by using the power of graphics processing units (GPUs). It is a framework developed by NVIDIA in 2006. CUDA allows developers to write programs that divide large computing tasks into smaller ones using parallel computing. 

This uses the many cores of a GPU to perform multiple calculations simultaneously—unlike a CPU, which uses a few powerful cores optimized for sequential processing. This parallel processing capability significantly speeds up tasks that involve large datasets or complex computations, such as those found in graphics rendering, scientific simulations, and machine learning.

Nvidia’s CUDA has been around for more than two decades and due to the popularity and inherent compatibility with its parent company’s physical video cards, it has emerged as one of the leaders in the industry. And even though CUDA’s chokehold on the space is breaking, it remains a top choice for accelerating training for machine learning models.

Industries using CUDA 

We’ve talked about the advantages of using GPUs and how you can use CUDA to program them to work on specific tasks. The most popular use case now is the rise of machine learning and AI, but we’ve listed down a couple of other industries that you may not know about that can also utilize the advantage of GPU computing power.

Challenges in learning CUDA development

While utilizing GPUs and programming them with CUDA is a rising framework, there is still a significant barrier to becoming a skilled CUDA programmer. Its biggest strength is also one of its complicating factors in learning. CUDA is designed for parallel computing, which is fundamentally different from traditional serial programming. Programmers need to grasp concepts like threads, blocks, and grids, and how they map to GPU hardware.

In addition to that, C/C++, a lower level language usually suited for intermediate developers, is arguably the language to learn if you want to maximize programming in CUDA (You can also opt for Python using PyTorch or Jax).

Lastly, CUDA requires a deeper knowledge on physical hardware (aka what NVIDIA GPU/s you’re using). There is extra setup involved both in hardware and software toolkits to access basic development and testing. Achieving high performance will also require studying the GPU architecture and careful optimization of code and tight memory management.

Setting up your first CUDA programming project

A CUDA .cu file with proper syntax highlighting and code analysis features opened in Visual Studio.

Starting with your first ever CUDA project may seem daunting but with the right directions, you can easily configure Visual Studio for CUDA programming projects in just an hour. Follow these steps below to get started:

Installing Visual Studio

Visual Studio is a good first option for an IDE if you are familiar with C++ already. It is compatible with the integration of the NVIDIA CUDA Toolkit which allows you to compile, debug, and optimize CUDA applications within the same platform.

• Download Visual Studio
  
  First, download Visual Studio from Microsoft. Choose whatever edition you prefer. For our installation, we downloaded a community version of Visual Studio 2022 for as it’s the latest supported version for our Windows 11 system. 
• Run the installer to complete the installation
  
  Follow the succeeding prompts until you get to the Visual Studio installer. It will ask you for a couple of things such as install directory and will check a couple of dependencies. Afterwards, you should be able to launch Visual Studio from this Window or from a shortcut.

Installing the CUDA Toolkit

With Visual Studio now installed, you will need the CUDA Toolkit download for Visual Studio. It provides the tools, libraries, and compiler (nvcc) needed to develop and run CUDA applications within Visual Studio. It enables integration for GPU-accelerated computing, which allows use of NVIDIA GPUs for high-performance tasks.

• Verify you have a CUDA-compatible GPU
  To ensure smooth operations, first check if your current GPU is a supported device. You can do this by navigating to the Display Adapters section in the Windows Device Manager. For more information, visit NVIDIA’s install guide. 
• Download CUDA Toolkit from NVIDIA
  
  Visit NVIDIA’s website to download and learn more about the toolkit. Before downloading, ensure that you have chosen the correct OS, version, etc. The download file in our case is 3.2 GB but please ensure you have at least 10 GB of free space as you still need to temporarily extract the installation files before running the installer.
  
  
• Run the installer
  
  After downloading, run the installer. It will scan your device for any missing dependencies or pre-existing installs and adjust your installation files accordingly. Afterwards, you will now have the CUDA Toolkit installed on your system. Additionally, NSIGHT which provides debugging and profiling features specific for CUDA applications will also be installed.
  
  If you encounter any issues with installing the toolkit, consult NVIDIA’s installation and troubleshooting guide.
  
  Bonus tip: If you prefer Visual Studio Code, you should install Nsight from this link instead. It’s an application development environment for “heterogeneous platforms that brings CUDA development for GPUs” into Microsoft’s Visual Studio code instead.
  

Getting started with your first CUDA project in Visual Studio

After installing both Visual Studio and the CUDA toolkit, you are now ready to initialize your first project within Visual Studio.

• Creating a new project.
  Start by opening Visual Studio and create a new project or clone an existing repository to start your first project file.
  
• Initializing your project.
  
  At this point you have two options: either start a completely blank console/project or choose the CUDA 12.8 project. The main difference is that the CUDA Runtime comes pre-equipped with the usual workloads, sample code, and use cases.However, starting from scratch allows you to configure your project with only what you need and it also familiarizes you with the workspace. For this project, we’ll start with a completely blank project.
• Setting your build configuration
  
  On the top of the Visual Studio window, choose Release and x64 (if you’re running a 64-bit system). This tells VS that we’re trying to build a version of an app that can be deployed, as opposed to debugging. 
• Adjusting build dependencies
  
  • 
  • 
  • 
  
  You need to ensure that Visual Studio knows that you’re trying to build and execute CUDA files. To configure this, right click on your project name (“CUDA Sample”) and click on Build Dependencies ? Build Customizations. A new window will pop up that lists down available build customization files—be sure to tick CUDA 12.8 and hit ok.
  
  
• Adding a CUDA C++ or Header file
  
  To add new source files, simply add new items as you would add any normal .cpp or .header file. Right click on a folder and click on Add ? New Item to access your file options. 
• Verifying file and project setup is correct
  At this point, we suggest trying to build a solution to ensure that everything is working smoothly. If nothing breaks, congratulations! You can now start working on your first CUDA file inside VS. NVIDIA also provides a few sample projects so you can test, debug, and familiarize with the setup using existing projects before creating a new one entirely.

Optimizing your setup

VS and NVIDIA have made giant strides in making CUDA development easier to access and set up. However, as CUDA is a proprietary language, there may still be some missing syntax highlighting or confused prompts from VS’s IntelliSense. 

To alleviate this, it is recommended to install supplementary plugins from the Visual Studio marketplace that can help with properly highlighting symbols. For example, you can download and install the Visual Assist plugin which adds support for CUDA-specific code that Visual Studio’s IntelliSense might not recognize yet. It also comes with the added benefit of providing its core features of navigation, refactoring, code assistance, and more, on top of the added support for .cu and .cuh files.

The Visual Assist plugin adds support for recognizing CUDA-specific code. VA recognizes you are using a symbol that references a missing header file and adds it for you.

Conclusion

While CUDA is a powerful tool that is likely to remain significant in the near future, the landscape of parallel computing is dynamic, and its dominance will depend on technological advancements and shifts in industry needs. But given the rapid growth of AI and machine learning, CUDA is likely to remain relevant due to its optimization for deep learning tasks, especially as NVIDIA continues to innovate in this space. 

In summary, if you’re looking to expand on your software development skills into a growing and forthcoming space, then learning CUDA could be it for you. 

The post Introduction to CUDA development + How to set up with Visual Studio first appeared on Tomato Soup.

Many of our most ardent Visual Assist champions are game developers, so for us, these cuts are not simply about numbers. This is about our user community – your careers, your livelihoods, and your families. And while the challenges and uncertainties that those affected now face might seem daunting, we know that carving out a career in the gaming industry requires talent, discipline, and grit. So if you are one of those personally affected by the cuts, even if your current situation feels overwhelming, we believe in your ability to rebound and forge a rewarding and successful career.

And as a company deeply rooted in this industry, we want to help. Maybe you can benefit from Visual Assist while you’re looking for a new position…maybe while making a demo. Maybe you’ll start a solo game and be the next indie hit. Maybe you simply want to keep your coding skills sharp while looking for your next opportunity.

To that end, we’re offering a 25% discount on our flagship product, Visual Assist, for any developer impacted by the recent layoffs. No questions asked, no proof of eligibility required – just an immediate 25% off on a personal license to help get you back on your feet.

You can grab the discount by using this link to get it now. While we know it’s not much, it’s our way of supporting and standing with those who’ve been affected. Since so many of you rely on Visual Assist for your work, we’ll ensure you still have the tools you need no matter your employment or economic situation.

And, of course, beyond the discount, know that our team is here to provide any resources or guidance you might need during this transitional period. Whether it’s helping you get more out of Visual Assist or collaborating on what we can do to improve the product for you, please reach out to us any time. We’re here to help!

Ultimately, our encouragement for those affected is to stay strong and remain vigilant. This is a highly competitive yet highly rewarding industry. New opportunities will come, even if you can’t see them yet. Take a break to clear your head if you need. We’ll be here when you get back.

The post On the recent video game industry layoffs first appeared on Tomato Soup.