A new Evergine 2025 Major Release!

We are excited to announce that the second major Evergine release of 2025 is here! We also want to celebrate surpassing 4.5 million downloads of our NuGet packages, a remarkable milestone that highlights Evergine’s growth as a powerful and reliable 3D graphics engine.

We remain committed to delivering the most advanced features for companies using Evergine, making the development of 3D industrial graphics applications easier and more efficient than ever before.

For over a decade, our licensing model has been built on a foundation of accessibility, ensuring that all users can benefit from its capabilities:

• Evergine is completely free for commercial use.
• No registration is required.
• We do not monitor your usage or activity.
• The license is valid for all industries.

For more information about our premium services visit our website.

For this version, following our principle of becoming the best option for creating 3D industrial graphics applications, we have introduced a new set of runtimes that natively support the most widely used industrial formats, including IFC, E57, USD, OBJ, STL, CAD, and PLY. We have also developed a custom renderer to visualize this type of data as point clouds, industrial models and plans, Gaussian splatting, and volumetric data.

In addition, we continue to improve the engine core with many significant features such as mesh shader support, Shader Model 6.7, KTX2 texture compression, and ARM64 compatibility across Windows, Linux, and macOS.

Download Evergine 2025 today!

• Installer
• Documentation
• Nuget packages
• Samples
• Feedback

The use of LiDAR sensors for space capturing is a common practice across many industries. However, companies often face the challenge of working with extremely large files that require powerful machines to visualize and process, since most point cloud viewers today still rely on outdated CPU-based techniques.

With this new version, we introduce an Evergine add-on that leverages high-performance compute shader based rasterization rendering. This provides a significantly faster experience combined with progressive rendering, allowing massive point clouds to be visualized even on standard laptops and reducing long loading times.

This new add-on enables customers to integrate point cloud viewers into existing applications in just a few hours, using the most advanced techniques available. It supports the most common point cloud formats such as LAS/LAZ, E57 and PCD, offering a more seamless experience, optimized for GPU powered small devices, and minimizing the need for expensive visualization licenses.

For a more detailed description of this new add-on, visit: Point Cloud add-on

Most of our customers use industrial file formats that are very different from the popular 3D formats commonly used in gaming, such as FBX or GLB/GLTF. After many projects helping companies work natively with their original files to avoid replicating their entire file catalog, we decided to include these capabilities as runtimes in the Evergine core.

In this version, we have added four important new runtimes:

• Runtimes.IFC
• Runtimes.USD
• Evergine Runtimes.CAD
• Runtimes.OBJ

The IFC format is the most widely used open standard in the architecture and construction industries within the BIM ecosystem. Many companies store their designs created with Revit in this format to make them easier to visualize or edit with other tools.

Another important addition is support for the USD format. Originally developed by Disney, USD has been adopted as a standard by major companies such as Apple and Nvidia, and it is now widely used in robotics simulation environments.

The CAD runtime is designed to load vector-based architectural files created with CAD software such as AutoCAD at runtime.

Finally, the OBJ runtime allows loading this human-readable 3D geometry format created by WaveFront, which is one of the most common formats for exchanging 3D models between different modeling tools.

For more information, visit: Support for New Evergine Runtimes

In previous versions of Evergine, we already supported WebGPU through WGPU, a project developed by Firefox. We also released experimental templates to use this backend for desktop applications, while we waited for a stable web browser implementation. However, that never happened. As a result, we decided to change our strategy, and the new backend is now based on Dawn from Google. With this change, new templates are finally available for web browser applications.

The Google implementation has progressed much faster, and WebGPU is now rapidly expanding across stable browser versions such as Chrome and Edge (starting from version 113), Safari (since version 26.0, released in September 2025), while Firefox offers partial support. This represents an inflection point that makes it the right time to adopt WebGPU over WebGL.

One of the most significant advantages of WebGPU is the support for compute shaders, a feature not available in WebGL. This enables major performance improvements for many rendering techniques and general-purpose algorithms that were previously executed on the CPU, now allowing them to run directly in the browser. It also makes it possible to perform AI model inference directly within web applications.

For a more detailed explanation of the new WebGPU backend, continue reading at:  WebGPU finally on Web

The resolution of textures in 3D graphics continues to increase over time because more detail translates into better visual quality. These textures must be loaded from disk and stored in GPU memory (VRAM) to be used during rendering.

Using uncompressed textures is not an option on platforms such as the web, because all that data would need to be transferred over the network before rendering can begin. Popular compressed image formats like JPEG or PNG reduce storage requirements on disk and the amount of data that needs to be transferred, which is useful for web applications. However, they cannot be interpreted directly by graphics cards (GPUs), so they must first be decompressed on the CPU side, and the final memory usage on the GPU is almost the same as the original uncompressed texture.

In this release, we have added support for the most advanced solution to this problem, created by the Khronos Group, called KTX2. This format allows textures to be compressed on disk like JPEG, but with the added advantage that the data can be directly interpreted by the GPU during rendering. As a result, it reduces loading times, lowers GPU memory usage, decreases bandwidth requirements, and improves frame rates.

KTX2 is a universal GPU texture compression format that supports the most widely used compression standards across different platforms, including Basis Universal (ETC1S + UASTC), BC1–BC7, ETC1/ETC2, PVRTC, and ASTC. All these formats are now supported as a core capability in Evergine.

More detailed information at: KTX2 Texture Compression

We have expanded Shader Model support to Shader Model 6.7 in this new version. This update allows us to include Mesh Shader support in our low-level API.

The Mesh Shader feature was introduced by Nvidia to significantly increase the amount of geometry that can be rendered in real time. The traditional graphics pipeline includes several stages that were added over time, such as the Geometry Shader, which increased flexibility but also introduced inefficiencies. The mesh shading pipeline redefines this process with a new approach focused on the capabilities of modern graphics hardware.

With this feature, new geometry rendering algorithms based on meshlets can be executed directly on the GPU, and techniques such as culling can be moved from the CPU to the GPU. This results in a considerable performance improvement in scenarios where massive amounts of geometry need to be rendered.

This new feature is currently supported on DirectX 12 and Vulkan. For more information, visit: Mesh Shaders and Meshlets support

With this release, Evergine now runs natively on ARM64 processors across Windows, macOS, and Linux. This means developers can build and run Evergine projects directly from ARM-based devices, including Apple Silicon Macs, Windows on ARM laptops, and Linux ARM machines, without relying on emulation.

This update brings full support for compiling projects for any platform supported by Evergine and .NET, while improving build performance and reducing resource usage on ARM hardware.

The adoption of ARM64 architectures is accelerating, both on personal devices and in the cloud. Major cloud providers such as AWS, Azure, and Google Cloud now offer ARM-based virtual machines that deliver higher performance with lower operational costs.

After introducing this feature in preview in the previous version, we have now resolved compatibility issues, enhanced stability, and reached a fully production-ready implementation.

Evergine continues to evolve to meet the demands of modern development, ensuring our tools are efficient, future-proof, and optimized for the next generation of computing platforms.

With this release, Evergine is fully compatible with Android SDK 35, ensuring that applications built with our engine continue to meet Google Play’s latest publishing requirements starting in August 2025.

This update includes important changes to our Android templates and native dependencies, allowing developers to build, compile, and publish projects targeting the new SDK without interruptions. It also ensures that Evergine apps remain compliant with the latest security, performance, and privacy standards required by the Android platform.

As part of this effort, Evergine’s Android and MAUI templates have been updated to target .NET 9, enabling a smoother build process and full compatibility with the latest Android toolchains. Additionally, we have addressed new technical requirements such as 16 KB memory page alignment for native libraries, ensuring that projects run correctly on devices using Android 16 and beyond.

These improvements guarantee that Evergine developers can continue distributing their applications through Google Play, for more details information about the requirements from Google and changes applied to the Android templates visit: evergine.com/ensuring-evergine-android-apps-stay-compatible-with-google-play

Gaussian Splatting quality enhancements

Gaussian Splatting is one of the most exciting advances in 3D visualization in recent years, delivering visual quality comparable to Neural Radiance Fields (NeRF) but in real time and with full support for web browser platforms. This technology pushes beyond what was possible with traditional photogrammetry, producing significantly better results for challenging materials commonly used in digitalization projects, such as glass or metal.

This new approach is also faster to generate than conventional 3D Digital Twin models, thanks to AI-based inference, and it supports operations such as measuring distances directly within the reconstructed space, similar to workflows with heavy point clouds.

After working with several companies on custom implementations, we are now releasing a new Evergine add-on that allows developers to easily create Gaussian Splatting viewers for both desktop and web platforms. This brings cutting-edge capabilities to industries such as architecture, construction, retail, automotive, real estate, and media virtual production.

Visit the next article for more information: evergine.com/improvements-in-gaussian-splatting-add-on

The new version of Evergine introduces hardware-accelerated gamma decoding, improving both rendering performance and color accuracy. 

Previously, gamma correction was handled in the pixel shader, which was expensive and could lead to inaccuracies, especially with mipmapping and interpolation. Now, by marking textures as sRGB, the GPU performs gamma decoding automatically during sampling, resulting in faster rendering and more accurate visuals. 

We also recommend enabling sRGB framebuffers, allowing the GPU to handle gamma encoding directly and further reducing shader workload. 

If you update an existing project, you might notice that textures appear brighter. This is expected due to the new gamma workflow. To fix it: 

• Update your project from the Evergine launcher. 

• Download the evergine_project_upgrade.py script. 

• Run the script with:  

python3 evergine_project_upgrade.py path/to/my_evergine.weproj 

• Review the textures and ensure those that require gamma correction are marked as sRGB. 

• (Optional) Update your framebuffer format to PixelFormat.R8G8B8A8_UNorm_SRgb for optimal performance. 

With these steps, your project will be fully optimized for the new hardware-based gamma pipeline. 

We are living in an extraordinary era of computer science, with rapid advances in Artificial Intelligence (AI) unlocking unprecedented opportunities for industries to improve efficiency and gain greater control of their operations through digitalization.

Our commitment is to continue integrating cutting-edge capabilities into Evergine to make these technologies more accessible, from 3D asset generation and high-performance point cloud rendering to AI-powered spatial understanding and digitalization based on Gaussian Splatting.

The roadmap for our next release includes support for additional industrial file formats, enabling companies to build 3D tools that can directly handle their raw data without complex conversions. We are also investing heavily in improving our development tools. The next version of Evergine Studio will deliver significant performance improvements and introduce MCP integration, allowing users to interact with and control the environment using AI models.

In parallel, we are designing a new GPU-driven rendering pipeline that leverages the latest graphics API features and introducing a new job system to parallelize CPU-side operations. These improvements will prepare Evergine to take full advantage of next-generation GPUs and multi-core CPU architectures, unlocking maximum performance across modern hardware.

Looking ahead to 2026, we plan to deprecate the DirectX11 backend and adopt DirectX12 as the default graphics API for Evergine Studio. This long-term shift will enable us to continue evolving our GPU-driven rendering architecture and push the boundaries of real-time visualization and simulation.Thank you for supporting Evergine! We remain committed to continuously improving Evergine’s technology to help companies build better products.

We hope you enjoy this new release!

Javier Cantón