63-575: Vulkan is a low-level, low- overhead cross-platform API and open standard for 3D graphics and computing . It was intended to address the shortcomings of OpenGL , and allow developers more control over the GPU . It is designed to support a wide variety of GPUs, CPUs and operating systems, and it is also designed to work with modern multi-core CPUs. Vulkan targets high-performance real-time 3D-graphics applications, such as video games and interactive media , and highly parallelized computing . Vulkan
126-612: A journal on some file systems. Many small files create more overhead than a low number of large files. Shader In computer graphics , a shader is a computer program that calculates the appropriate levels of light , darkness , and color during the rendering of a 3D scene —a process known as shading . Shaders have evolved to perform a variety of specialized functions in computer graphics special effects and video post-processing , as well as general-purpose computing on graphics processing units . Traditional shaders calculate rendering effects on graphics hardware with
189-447: A payload of data over a communications network requires sending more than just the payload itself. It also involves sending various control and signalling data ( TCP ) required to reach the destination. This creates a so-called protocol overhead as the additional data does not contribute to the intrinsic meaning of the message. In telephony , number dialing and call set-up time are overheads. In two-way (but half-duplex ) radios,
252-586: A Linux driver for Intel which enabled Vulkan compatibility on the HD 4000 series integrated graphics, despite the open-source Mesa drivers not being fully compatible with OpenGL 4.0 until later that year. There is still the possibility of Sandy Bridge support, since it supports compute through Direct3D11. On August 10, 2015, Google announced that future versions of Android would support Vulkan. Android 7.x "Nougat" launched support for Vulkan on August 22, 2016. Android 8.0 "Oreo" has full support. On December 18, 2015,
315-471: A better approximation of a curve. As of OpenGL 4.0 and Direct3D 11, a new shader class called a tessellation shader has been added. It adds two new shader stages to the traditional model: tessellation control shaders (also known as hull shaders) and tessellation evaluation shaders (also known as Domain Shaders), which together allow for simpler meshes to be subdivided into finer meshes at run-time according to
378-544: A big financial incentive to do so. Often, even though software providers are well aware of bugs in their products, the payoff of fixing them is not worth the reward, because of the overhead. For example, an implicit data structure or succinct data structure may provide low space overhead, but at the cost of slow performance (space/time tradeoff). Algorithmic complexity is generally specified using Big O notation . This makes no comment on how long something takes to run or how much memory it uses, but how its increase depends on
441-421: A choice of several algorithms , encodings , data types or data structures , each of which have known characteristics. When choosing among them, their respective overhead should also be considered. In software engineering , overhead can influence the decision whether or not to include features in new products, or indeed whether to fix bugs. A feature that has a high overhead may not be included – or needs
504-426: A color value; more complex shaders with multiple inputs/outputs are also possible. Pixel shaders range from simply always outputting the same color, to applying a lighting value, to doing bump mapping , shadows , specular highlights , translucency and other phenomena. They can alter the depth of the fragment (for Z-buffering ), or output more than one color if multiple render targets are active. In 3D graphics,
567-403: A final rendered image can be altered using algorithms defined in a shader, and can be modified by external variables or textures introduced by the computer program calling the shader. Shaders are used widely in cinema post-processing , computer-generated imagery , and video games to produce a range of effects. Beyond simple lighting models, more complex uses of shaders include: altering
630-565: A geometry shader if present, or the rasterizer . Vertex shaders can enable powerful control over the details of position, movement, lighting, and color in any scene involving 3D models . Geometry shaders were introduced in Direct3D 10 and OpenGL 3.2; formerly available in OpenGL 2.0+ with the use of extensions. This type of shader can generate new graphics primitives , such as points, lines, and triangles, from those primitives that were sent to
693-471: A geometry shader include point sprite generation, geometry tessellation , shadow volume extrusion, and single pass rendering to a cube map . A typical real-world example of the benefits of geometry shaders would be automatic mesh complexity modification. A series of line strips representing control points for a curve are passed to the geometry shader and depending on the complexity required the shader can automatically generate extra lines each of which provides
SECTION 10
#1732776603549756-612: A high degree of flexibility. Most shaders are coded for (and run on) a graphics processing unit (GPU), though this is not a strict requirement. Shading languages are used to program the GPU's rendering pipeline , which has mostly superseded the fixed-function pipeline of the past that only allowed for common geometry transforming and pixel-shading functions; with shaders, customized effects can be used. The position and color ( hue , saturation , brightness , and contrast ) of all pixels , vertices , and/or textures used to construct
819-540: A kickoff meeting at Valve . At SIGGRAPH 2014, the project was publicly announced with a call for participants. According to the US Patent and Trademark Office, the trademark for Vulkan was filed on February 19, 2015. Vulkan was formally named and announced at Game Developers Conference 2015, although speculation and rumors centered around a new API existed beforehand and referred to it as " glNext ". In early 2015, LunarG (funded by Valve ) developed and showcased
882-418: A mathematical function. The function can be related to a variety of variables, most notably the distance from the viewing camera to allow active level-of-detail scaling. This allows objects close to the camera to have fine detail, while further away ones can have more coarse meshes, yet seem comparable in quality. It also can drastically reduce required mesh bandwidth by allowing meshes to be refined once inside
945-479: A per-vertex basis. Newer geometry shaders can generate new vertices from within the shader. Tessellation shaders are the newest 3D shaders; they act on batches of vertices all at once to add detail—such as subdividing a model into smaller groups of triangles or other primitives at runtime, to improve things like curves and bumps , or change other attributes. Vertex shaders are the most established and common kind of 3D shader and are run once for each vertex given to
1008-647: A pixel shader alone cannot produce some kinds of complex effects because it operates only on a single fragment, without knowledge of a scene's geometry (i.e. vertex data). However, pixel shaders do have knowledge of the screen coordinate being drawn, and can sample the screen and nearby pixels if the contents of the entire screen are passed as a texture to the shader. This technique can enable a wide variety of two-dimensional postprocessing effects such as blur , or edge detection /enhancement for cartoon/cel shaders . Pixel shaders may also be applied in intermediate stages to any two-dimensional images— sprites or textures —in
1071-418: A small run-time overhead. Sometimes the compiler can minimize this overhead by inlining some of these function calls . In a CPU cache , the "cache size" (or capacity ) refers to how much data a cache stores. For instance, a "4 KB cache" is a cache that holds 4 KB of data. The "4 KB" in this example excludes overhead bits such as frame, address, and tag information. Reliably sending
1134-434: A vertex, while pixel shaders describe the traits (color, z-depth and alpha value) of a pixel. A vertex shader is called for each vertex in a primitive (possibly after tessellation ); thus one vertex in, one (updated) vertex out. Each vertex is then rendered as a series of pixels onto a surface (block of memory) that will eventually be sent to the screen. Shaders replace a section of the graphics hardware typically called
1197-479: Is a large pixel matrix or " frame buffer ". There are three types of shaders in common use (pixel, vertex, and geometry shaders), with several more recently added. While older graphics cards utilize separate processing units for each shader type, newer cards feature unified shaders which are capable of executing any type of shader. This allows graphics cards to make more efficient use of processing power. 2D shaders act on digital images , also called textures in
1260-430: Is designed to allow developers to better distribute work among multiple CPU cores . Vulkan was first announced by the non-profit Khronos Group at GDC 2015. The Vulkan API was initially referred to as the "next generation OpenGL initiative", or "OpenGL next" by Khronos, but use of those names was discontinued when "Vulkan" was announced. Vulkan is derived from and built upon components of AMD 's Mantle API, which
1323-630: Is incomplete Vulkan support for Haswell with it not being Vulkan 1.0 compliant. Apart from Haswell, Ivy Bridge and Broadwell are also supported by a legacy Vulkan driver in Mesa called HASVK. Skylake and newer being supported by a driver in Mesa called ANV. On Windows, Vulkan 1.2 is supported from GCN 1.0 to GCN 3.0, with no further updates planned after June 2021. GCN 4.0 and newer support Vulkan 1.3. On Linux there are various different Vulkan drivers with varying and overlapping hardware support. There
SECTION 20
#17327766035491386-405: Is intended to offer higher performance and more efficient CPU and GPU usage compared to the older OpenGL and Direct3D 11 APIs. It does so by providing a considerably lower-level API for the application than the older APIs, that more closely resembles how modern GPUs work. Vulkan is comparable to Apple's Metal API and Microsoft's Direct3D 12 . In addition to its lower CPU usage, Vulkan
1449-533: Is similar to concepts seen in Mantle and later adopted by Microsoft with Direct3D 12 and Apple with Metal . Intended advantages of Vulkan over previous-generation APIs include the following: Vulkan is available on multiple modern operating systems and architectures , and provides a single API for both desktop and mobile graphics devices, whereas previously these were split between OpenGL and OpenGL ES respectively. Like OpenGL, and in contrast to Direct3D 12,
1512-491: Is still a great option for a lot of use cases, as it comes at a much lower complexity and maintenance burden than Vulkan, while in many cases still providing great overall performance." AMD states that "Vulkan supports close-to-metal control, enabling faster performance and better image quality across Windows 7, Windows 8.1, Windows 10, and Linux. No other graphics API offers the same powerful combination of OS compatibility, rendering features, and hardware efficiency." Vulkan 1.0
1575-482: Is the open-source Vulkan driver called AMDVLK, developed by AMD which mirrors Windows support. There is also the proprietary driver called AMDGPU-PRO which is not recommended to be used for most users as of March 2023. There is also the recommended driver called RADV in Mesa developed by Valve, Red Hat, Google and others. This driver as of March 2023 supports all GCN and RDNA cards. This RADV driver's support for GCN 1.0 through GCN 2.0 requires its experimental support in
1638-454: Is the world's first GPU microarchitecture that supports mesh shading through DirectX 12 Ultimate API, several months before Ampere RTX 30 series was released. In 2020, AMD and Nvidia released RDNA 2 and Ampere microarchitectures which both support mesh shading through DirectX 12 Ultimate . These mesh shaders allow the GPU to handle more complex algorithms, offloading more work from the CPU to
1701-657: Is thus similar to overhead in organizations. Computer system overhead shows up as slower processing, less memory, less network bandwidth, or bigger latency than would be expected from reading the system specifications. It is a special case of engineering overhead . Overhead can be a deciding factor in software design, with regard to structure, error correction, and feature inclusion. Examples of computing overhead may be found in Object Oriented Programming (OOP), functional programming , data transfer, and data structures. A programmer/software engineer may have
1764-456: The Metal framework . Modern video game development platforms such as Unity , Unreal Engine and Godot increasingly include node-based editors that can create shaders without the need for actual code; the user is instead presented with a directed graph of connected nodes that allow users to direct various textures, maps, and mathematical functions into output values like the diffuse color,
1827-798: The amdgpu kernel module to be enabled. On Windows and Linux there is the NVIDIA developed Vulkan driver which supports Vulkan 1.2 on Kepler cards with no further updates planned after September 2021. Maxwell and newer support Vulkan 1.3. NVK, an experimental, open source Vulkan driver for Linux based on nouveau , was announced in October 2022. It was merged into mainline Mesa in August 2023. The driver currently supports Vulkan 1.3 Overhead (computing) Overhead in computer systems consists of shared functions that benefit all users or processes but are not directly attributable to any specific task. It
1890-427: The hue , saturation , brightness ( HSL/HSV ) or contrast of an image; producing blur , light bloom , volumetric lighting , normal mapping (for depth effects), bokeh , cel shading , posterization , bump mapping , distortion , chroma keying (for so-called "bluescreen/ greenscreen " effects), edge and motion detection , as well as psychedelic effects such as those seen in the demoscene . This use of
1953-433: The pipeline , whereas vertex shaders always require a 3D scene. For instance, a pixel shader is the only kind of shader that can act as a postprocessor or filter for a video stream after it has been rasterized . 3D shaders act on 3D models or other geometry but may also access the colors and textures used to draw the model or mesh . Vertex shaders are the oldest type of 3D shader, generally making modifications on
Vulkan - Misplaced Pages Continue
2016-436: The 32-bit signed integer 1310447927 , consuming only 4 bytes. Represented as ISO 8601 formatted UTF-8 encoded string 2011-07-12 07:18:47 the date would consume 19 bytes, a size overhead of 375% over the binary integer representation. As XML this date can be written as follows with an overhead of 218 characters, while adding the semantic context that it is a CHANGEDATE with index 1. The 349 bytes, resulting from
2079-615: The CPU can be used in conjunction with a high-end dedicated GPU for a slight performance boost. On March 7, 2018, Vulkan 1.1 was released by the Khronos Group. This first major update to the API standardized several extensions, such as multi-view, device groups, cross-process and cross-API sharing, advanced compute functionality, HLSL support, and YCbCr support. At the same time, it also brought better compatibility with DirectX 12, explicit multi-GPU support, ray tracing support, and laid
2142-487: The Fixed Function Pipeline (FFP), so-called because it performs lighting and texture mapping in a hard-coded manner. Shaders provide a programmable alternative to this hard-coded approach. The basic graphics pipeline is as follows: The graphic pipeline uses these steps in order to transform three-dimensional (or two-dimensional) data into useful two-dimensional data for displaying. In general, this
2205-795: The GPU, and in algorithm intense rendering, increasing the frame rate of or number of triangles in a scene by an order of magnitude. Intel announced that Intel Arc Alchemist GPUs shipping in Q1 2022 will support mesh shaders. Ray tracing shaders are supported by Microsoft via DirectX Raytracing , by Khronos Group via Vulkan , GLSL , and SPIR-V , by Apple via Metal . Tensor shaders may be integrated in NPUs or GPUs . Tensor shaders are supported by Microsoft via DirectML , by Khronos Group via OpenVX , by Apple via Core ML , by Google via TensorFlow , by Linux Foundation via ONNX . Compute shaders are not limited to graphics applications, but use
2268-498: The Khronos Group announced that OpenCL would converge where possible with Vulkan to enable OpenCL software deployment flexibility over both APIs. This has been now demonstrated by Adobe 's Premiere Rush using the clspv open source compiler to compile significant amounts of OpenCL C kernel code to run on a Vulkan runtime for deployment on Android. The Khronos Group began a project to create a next generation graphics API in July 2014 with
2331-693: The Khronos Group announced that the 1.0 version of the Vulkan specification was nearly complete and would be released when conforming drivers were available. The full Vulkan specification and the open-source Vulkan SDK were released on February 16, 2016. On February 26, 2018, Khronos Group announced that the Vulkan API became available to all on macOS and iOS through the MoltenVK library, which enables Vulkan to run on top of Metal . Other new developments were shown at SIGGRAPH 2018. Previously MoltenVK
2394-635: The Raspberry Pi Foundation announced that it was working on an open source Vulkan driver for their Raspberry Pi , a popular single board computer. On June 20, 2020, a graphics engineer revealed that he had created one after two years of work that was capable of running VkQuake3 at over 100FPS on the small computer. On March 17, 2020, Khronos Group released the Ray Tracing extensions, based on Nvidia 's proprietary extension, with some major extensions and many minor changes, which in turn
2457-464: The UTF-8 encoded XML, correlates to a size overhead of 8625% over the original integer representation. Besides the files themselves, computer file systems take a portion of the space to store directory names and listings, file names, files' sector locations, attributes such as the date and time of the last modification and creation, how the files are fragmented , written and free parts of the space, and
2520-1080: The Vulkan 1.2 standard. On August 1, 2022, Raspberry Pi Foundation announced that their driver for the Raspberry Pi 4 is Vulkan 1.2 conformant. On September 1, 2022, Mesh Shading for Vulkan was released. A new Vulkan Roadmap was announced on January 25. A new extension for decoding AV1 video was released on February 1. Initial specifications stated that Vulkan drivers can be implemented on any hardware that supports OpenGL ES 3.1 or OpenGL 4.x and up. As Vulkan support requires new graphics drivers, this does not necessarily imply that every existing device that supports OpenGL ES 3.1 or OpenGL 4.x will have Vulkan drivers available. As of March 2023, Intel has split Vulkan driver support on Windows and on Linux . All drivers are developed by Intel. On Windows, Skylake to Ice Lake supports up to Vulkan 1.3, with limited support after July 2022 as future updates will only cover security fixes. Iris Xe and newer are fully supported as of March 2023. On Linux, as of March 2023 there
2583-401: The Vulkan API is not locked to a single OS or device form factor. Vulkan runs natively on Android , Linux , BSD Unix , QNX , Haiku , Nintendo Switch , Raspberry Pi , Stadia , Fuchsia , Tizen , and Windows 7 , 8 , 10 , and 11 . MoltenVK provides freely licensed third-party support for macOS , iOS and tvOS by wrapping over Apple's Metal API. Vulkan reduces load on CPUs through
Vulkan - Misplaced Pages Continue
2646-421: The beginning of the graphics pipeline . Geometry shader programs are executed after vertex shaders. They take as input a whole primitive, possibly with adjacency information. For example, when operating on triangles, the three vertices are the geometry shader's input. The shader can then emit zero or more primitives, which are rasterized and their fragments ultimately passed to a pixel shader . Typical uses of
2709-702: The binary format that HLSL shaders are compiled into in Direct3D . By allowing shader pre-compilation, application initialization speed is improved and a larger variety of shaders can be used per scene. A Vulkan driver only needs to perform GPU specific optimization and code generation, resulting in easier driver maintenance, and potentially smaller driver packages. The developers of applications now can also more easily obfuscate proprietary shader code, due to shaders not being stored directly as source code, however tools are provided that can decompile SPIR-V to human-readable high-level code . In 2016 NVIDIA stated that "OpenGL
2772-417: The field of computer graphics. They modify attributes of pixels . 2D shaders may take part in rendering 3D geometry . Currently the only type of 2D shader is a pixel shader. Pixel shaders, also known as fragment shaders, compute color and other attributes of each "fragment": a unit of rendering work affecting at most a single output pixel . The simplest kinds of pixel shaders output one screen pixel as
2835-461: The graphics processor. The purpose is to transform each vertex's 3D position in virtual space to the 2D coordinate at which it appears on the screen (as well as a depth value for the Z-buffer). Vertex shaders can manipulate properties such as position, color and texture coordinates, but cannot create new vertices. The output of the vertex shader goes to the next stage in the pipeline, which is either
2898-447: The groundwork for the next generation of GPUs. Alongside Vulkan 1.1, SPIR-V was updated to version 1.3. On January 15, 2020, Vulkan 1.2 was released by the Khronos Group. This second major update to the API integrates 23 additional commonly-used proven Vulkan extensions into the base Vulkan standard. Some of the most important features are "timeline semaphores for easily managed synchronization", "a formal memory model to precisely define
2961-477: The modernized threading architecture. OpenGL uses the high-level language GLSL for writing shaders , which forces each OpenGL driver to implement its own compiler for GLSL. This then executes at application runtime to translate the program's shaders into the GPU's machine code. In contrast, Vulkan drivers are supposed to ingest shaders already translated into an intermediate binary format called SPIR-V (Standard Portable Intermediate Representation), analogous to
3024-512: The power of shaders. The first video card with a programmable pixel shader was the Nvidia GeForce 3 (NV20), released in 2001. Geometry shaders were introduced with Direct3D 10 and OpenGL 3.2. Eventually, graphics hardware evolved toward a unified shader model . Shaders are simple programs that describe the traits of either a vertex or a pixel . Vertex shaders describe the attributes (position, texture coordinates , colors, etc.) of
3087-404: The same execution resources for GPGPU . They may be used in graphics pipelines e.g. for additional stages in animation or lighting algorithms (e.g. tiled forward rendering ). Some rendering APIs allow compute shaders to easily share data resources with the graphics pipeline. Shaders are written to apply transformations to a large set of elements at a time, for example, to each pixel in an area of
3150-585: The screen, or for every vertex of a model. This is well suited to parallel processing , and most modern GPUs have multiple shader pipelines to facilitate this, vastly improving computation throughput. A programming model with shaders is similar to a higher order function for rendering, taking the shaders as arguments, and providing a specific dataflow between intermediate results, enabling both data parallelism (across pixels, vertices etc.) and pipeline parallelism (between stages). (see also map reduce ). The language in which shaders are programmed depends on
3213-423: The semantics of synchronization and memory operations in different threads", and "descriptor indexing to enable reuse of descriptor layouts by multiple shaders". The additional features of Vulkan 1.2 improve its flexibility when it comes to implementing other graphics APIs on top of Vulkan, including "uniform buffer standard layout", "scalar block layout", and "separate stencil usage". On January 25, 2022, Vulkan 1.3
SECTION 50
#17327766035493276-618: The shader units instead of downsampling very complex ones from memory. Some algorithms can upsample any arbitrary mesh, while others allow for "hinting" in meshes to dictate the most characteristic vertices and edges. Circa 2017, the AMD Vega microarchitecture added support for a new shader stage—primitive shaders—somewhat akin to compute shaders with access to the data necessary to process geometry. Nvidia introduced mesh and task shaders with its Turing microarchitecture in 2018 which are also modelled after compute shaders. Nvidia Turing
3339-405: The size of the input. Overhead is deliberately not part of this calculation, since it varies from one machine to another, whereas the fundamental running time of an algorithm does not. This should be contrasted with algorithmic efficiency , which takes into account all kinds of resources – a combination (though not a trivial one) of complexity and overhead. Invoking a function introduces
3402-460: The target environment. The official OpenGL and OpenGL ES shading language is OpenGL Shading Language , also known as GLSL, and the official Direct3D shading language is High Level Shader Language , also known as HLSL. Cg , a third-party shading language which outputs both OpenGL and Direct3D shaders, was developed by Nvidia ; however since 2012 it has been deprecated. Apple released its own shading language called Metal Shading Language as part of
3465-472: The term "shader" was introduced to the public by Pixar with version 3.0 of their RenderMan Interface Specification, originally published in May 1988. As graphics processing units evolved, major graphics software libraries such as OpenGL and Direct3D began to support shaders. The first shader-capable GPUs only supported pixel shading , but vertex shaders were quickly introduced once developers realized
3528-501: The use of batching and other low-level optimizations, therefore reducing CPU workloads and leaving the CPU free to do more computation or rendering than would otherwise be possible. Direct3D 11 and OpenGL 4 were initially designed for use with single-core CPUs and only received augmentation to be executed on multi-cores. Even when application developers use the augmentations, these APIs regularly do not scale well on multi-cores. Vulkan offers improved scalability on multi-core CPUs due to
3591-399: The use of "over" and other signaling needed to avoid collisions is an overhead. Protocol overhead can be expressed as a percentage of non-application bytes (protocol and frame synchronization ) divided by the total number of bytes in the message. The encoding of information and data introduces overhead too. The date and time "2011-07-12 07:18:47" can be expressed as Unix time with
3654-563: Was a proprietary and commercially licensed solution, but Valve made an arrangement with developer Brenwill Workshop Ltd to open-source MoltenVK under the Apache 2.0 license and as a result the library is now available on GitHub . Valve also announced that Dota 2 can as of February 26, 2018 run on macOS using the Vulkan API, which is based on MoltenVK. On February 25, 2019, the Vulkan Safety Critical (SC) Working Group
3717-609: Was announced to bring Vulkan GPU acceleration to safety critical industries. Google's Stadia streaming cloud gaming service used Vulkan on Linux based servers with AMD GPUs . On January 15, 2020, Vulkan 1.2 was released. Alongside the Vulkan 1.2 release, the Khronos Group posted a blog post which considered that HLSL support in Vulkan had reached "production ready" status, given the improvements in Microsoft's DXC compiler and Khronos's glslang compiler, and new features in Vulkan 1.2 which enhance HLSL support. On February 3, 2020,
3780-415: Was based on Nvidia's OptiX API. On November 23, 2020, these Ray Tracing extensions were finalized. On November 24, 2020, Raspberry Pi Foundation announced that their driver for the Raspberry Pi 4 is Vulkan 1.0 conformant. On January 25, 2022, Vulkan 1.3 was released. On March 1, 2022, Vulkan SC 1.0 was released, bringing Vulkan graphics and compute for the safety-critical industry while being based on
3843-411: Was donated by AMD to Khronos with the intent of giving Khronos a foundation on which to begin developing a low-level API that they could standardize across the industry. Vulkan is intended to provide a variety of advantages over other APIs as well as its predecessor, OpenGL . Vulkan offers lower overhead, more direct control over the GPU, and lower CPU usage. The overall concept and feature set of Vulkan
SECTION 60
#17327766035493906-474: Was released by the Khronos Group. This third major update to the API integrates 23 additional commonly-used proven Vulkan extensions into the base Vulkan standard. Vulkan 1.3 focuses on reducing fragmentation by making the new features not optional in order for a device to be considered Vulkan 1.3 capable. The new features in Vulkan 1.3 include dynamic rendering, additional dynamic state, improved synchronization API, and device profiles. When releasing OpenCL 2.2,
3969-530: Was released in February 2016. At SIGGRAPH 2016, Khronos announced that Vulkan would be getting support for automatic multi-GPU features, similar to what is offered by Direct3D 12. Multi-GPU support included in-API removes the need for SLI or Crossfire which requires graphics cards to be of the same model. API multi-GPU instead allows the API to intelligently split the workload among two or more completely different GPUs. For example, integrated GPUs included on
#548451