You can use post-processing effects to simulate physical camera and film properties, for example Bloom and Depth of Field. More info post processing, postprocessing, postprocess See in Glossary effects require this because they create Render Textures A special type of Texture that is created and updated at runtime. To use them, first create a new Render Texture and designate one of your Cameras to render into it.

Then you can use the Render Texture in a Material just like a regular Texture. More info See in Glossary in the same format as the display buffer. Indicates whether to disable depth and stencil buffers A memory store that holds an 8-bit per-pixel value. In Unity, you can use a stencil buffer to flag pixels, and then only render to pixels that pass the stencil operation.

For this setting to take effect, set your Camera A component which creates an image of a particular viewpoint in your scene. The output is either drawn to the screen or captured as a texture. Specifies the texture that the application uses for the Android splash screen. The standard size for the splash screen image is x Scales the image so that the longer dimension fits the screen size exactly. Unity fills in the empty space around the sides in the shorter dimension in black.

Scales the image so that the shorter dimension fits the screen size exactly. Unity crops the image in the longer dimension. Choose which color space Unity uses for rendering: Gamma or Linear. For more information, see Linear rendering overview. Gamma : Gamma color space is typically used for calculating lighting on older hardware restricted to 8 bits per channel for the frame buffer format.

Even though monitors today are digital, they might still take a gamma-encoded signal as input. Linear : Linear color space rendering gives more precise results.

When you select to work in linear color space, the Editor defaults to using sRGB sampling. If your Textures are in linear color space, you need to work in linear color space and disable sRGB sampling for each Texture.

Disable this option to manually pick and reorder the graphics APIs. By default this option is enabled, and Unity tries to use Vulkan. There are three additional checkboxes to configure the minimum OpenGL ES 3. x minor version: Require ES3.

In this case only, your application does not appear on unsupported devices in the Google Play Store. You can add or remove color gamuts for the Android platform to use for rendering. A color gamut defines a possible range of colors available for a given device such as a monitor or screen. The sRGB gamut is the default and required gamut. When targeting devices with wide color gamut displays, use DisplayP3 to utilize full display capabilities. This can help to improve performance in applications that have high CPU usage on the main thread.

Uses Static batching. For more information, see Draw call batching. Uses dynamic batching enabled by default. Note: Dynamic batching has no effect when a Scriptable Render Pipeline is active, so this setting is only visible if the Scriptable Render Pipeline Asset Graphics setting is blank. Offloads graphics tasks render loops to worker threads running on other CPU cores.

This option reduces the time spent in Camera. Render on the main thread, which can be a bottleneck. Choose between ASTC, ETC2 and ETC ETC1 for RGB, ETC2 for RGBA. See texture compression format overview for more information on how to pick the right format.

See Texture compression settings for more details on how this interacts with the texture compression setting in the Build Settings. Choose XYZ or DXT5nm-style to set the normal map encoding. This affects the encoding scheme and compression format used for normal maps. DXT5nm-style normal maps are of higher quality, but more expensive to decode in shaders.

Defines the encoding scheme and compression format of the lightmaps. You can choose from Low Quality , Normal Quality , or High Quality. Uses Mipmap Streaming for lightmaps. Unity applies this setting to all lightmaps when it generates them. Note: To use this setting, you must enable the Texture Streaming Quality setting. Sets the priority for all lightmaps in the Mipmap Streaming system.

Positive numbers give higher priority. Valid values range from — to Use this option with the Dynamic Resolution A Camera setting that allows you to dynamically scale individual render targets, to reduce workload on the GPU. More info See in Glossary camera setting to determine if your application is CPU or GPU bound.

Indicates whether to enable Virtual Texturing. Controls the default precision of samplers used in shaders. For more information, see Shader data types and precision. Indicates whether Unity can capture stereoscopic images and videos. For more information, see Stereo Image and Video Capture. Enable this option to allow Graphics.

SetSRGBWrite renderer to toggle the sRGB write mode during runtime. That is, if you want to temporarily turn off Linear-to-sRGB write color conversion, you can use this property to achieve that.

Enabling this has a negative impact on performance on mobile tile-based GPUs; therefore, do NOT enable this for mobile. Set this option to 2 for double-buffering, or 3 for triple-buffering to use with Vulkan renderer. This setting may help with latency on some platforms, but in most cases you should not change this from the default value of 3. Double-buffering might have a negative impact on performance. Do not use this setting on Android. If enabled, Vulkan delays acquiring the backbuffer until after it renders the frame to an offscreen image.

Vulkan uses a staging image to achieve this. Enabling this setting causes an extra blit when presenting the backbuffer. This setting, in combination with double-buffering, can improve performance. However, it also can cause performance issues because the additional blit takes up bandwidth. Indicates whether to recycle or free CommandBuffers after Unity executes them.

Enable this to perform all rendering in the native orientation of the display. This has a performance benefit on many devices. For more information, see documentation on Vulkan swapchain pre-rotation. Indicates whether to override the default package name for your application. Note: This setting affects macOS, iOS, tvOS, and Android. Set the application ID, which uniquely identifies your app on the device and in Google Play Store.

The application ID must follow the convention com. YourProductName and must contain only alphanumeric and underscore characters. Each segment must start with an alphabetical character.

For more information, see Set the application ID. Important : Unity automatically removes any invalid characters you type. To set this property, enable Override Default Package Name. Enter the build version number of the bundle, which identifies an iteration released or unreleased of the bundle. The version is specified in the common format of a string containing numbers separated by dots eg, 4. Shared between iOS and Android. An internal version number. This number is used only to determine whether one version is more recent than another, with higher numbers indicating more recent versions.

This is not the version number shown to users; that number is set by the versionName attribute. You can define it however you want, as long as each successive version has a higher number.

For example, it could be a build number. Or you could simply increase the number by one each time a new version is released. Keep this number under if Split APKs by target architecture is enabled. Each APK must have a unique version code so Unity adds to the number for ARMv7, and for ARM Target Android version API level against which to compile the application.

Scripting Backend A framework that powers scripting in Unity. Unity supports three different scripting backends depending on target platform: Mono,. NET and IL2CPP. Universal Windows Platform, however, supports only two:. Choose the scripting backend you want to use. The scripting backend determines how Unity compiles and executes C code in your Project.

Compiles C code into. NET Common Intermediate Language CIL and executes that CIL using a Common Language Runtime.

See the Mono Project website for more information. See IL2CPP A Unity-developed scripting back-end which you can use as an alternative to Mono when building projects for some platforms. More info See in Glossary for more information. Choose which.

NET APIs you can use in your project. This setting can affect compatibility with third-party libraries. However, it has no effect on Editor-specific code code in an Editor directory, or within an Editor-specific Assembly Definition. Tip: If you are having problems with a third-party assembly, you can try the suggestion in the API Compatibility Level section below. Net 2. net compatibility, biggest file sizes. Part of the deprecated. NET 3. Compatible with. NET Standard 2.

Produces smaller builds and has full cross-platform support. Compatible with the. NET Framework 4 which includes everything in the. Choose this option when using libraries that access APIs not included in.

Produces larger builds and any additional APIs available are not necessarily supported on all platforms.

See Referencing additional class library assemblies for more information. Note: This property is disabled unless Scripting Backend is set to IL2CPP. Uses the incremental garbage collector, which spreads garbage collection over several frames to reduce garbage collection-related spikes in frame duration. For more information, see Automatic Memory Management.

Indicates whether Mono validates types from a strongly-named assembly. Enable this option if you want your Unity application to stop Audio from applications running in the background. Otherwise, Audio from background applications continues to play alongside your Unity application. Select which CPUs you want to allow the application to run on bit ARM, bit ARM, bit x86, and bit x86— Note : Running Android apps in a bit environment has performance benefits and bit apps can address more than 4 GB of memory space.

Enable this option to create a separate APK for each CPU architecture selected in Target Architectures. This makes download size smaller for Google Play Store users. This is primarily a Google Play store feature and may not work in other stores. For more details, refer to Multiple APK Support. Specifies application install location on the device for detailed information, refer to Android Developer documentation on install locations.

Install the application to external storage SD card if possible. Force the application to be installed to internal memory. The user will be unable to move the app to external storage. Choose whether to always add the networking INTERNET permission to the Android App Manifest , even if you are not using any networking APIs. Set to Require by default for development builds. Choose whether to enable write access to the external storage such as the SD card and add a corresponding permission to the Android App Manifest.

Set to External SDCard by default for development builds. Enable this option to discard touches received when another visible window is covering the Unity application. This is to prevent tapjacking. Enable this option to set a predictable and consistent level of device performance over longer periods of time, without thermal throttling. Overall performance might be lower when this setting is enabled. Based on the Android Sustained Performance API.

Un-check this setting to disable the default behavior. Enable this option to mark the output package APK as a game rather than a regular application. Choose the level of support your application offers for a gamepad. The options are Works with D-Pad , Supports Gamepad , and Requires Gamepad.

Enable this option to receive a warning when the size of the Android App Bundle exceeds a certain threshold. This option is selected by default and you can only configure it if you enable the Build App Bundle Google Play option in the Build settings.

Use the newer Input system. The Input System is provided as a preview package for this release. To try a preview of the Input System, install the InputSystem package. Sets the maximum size of compressed shader variant data chunks Unity stores in your built application for all platforms. The default is See Shader loading for more information. Sets the default limit on how many decompressed chunks Unity keeps in memory on all platforms.

Enables overriding Default chunk size and Default chunk count for this build target. Overrides the value of Default chunk size MB on this build target. Overrides the value of Default chunk count on this build target.

Set custom compilation flags. For more details, see the documentation on Platform dependent compilation. Add entries to this list to pass additional arguments to the Roslyn compiler. Use one new entry for each additional argument. When you have added all desired arguments, click the Apply button to include your additional arguments in future compilations.

The Revert button resets this list to the most recent applied state. Disable this setting to display the C warnings CS and CS For Assembly Definition Files. asmdef , click on one of your. asmdef files and enable the option in the Inspector window that appears. Synchronous collection also requires that application has been started with administrative privileges.

D3D12 Replay Fence Behavior. Choose the behavior when encountering a sync point during D3D12 replay. Modern APIs, such as D3D12, have fine-grained, application control of synchronization.

Tools must infer what the expectations of the application when identifying application syncs, and must do it in a way that allows for high performance while still respecting data hazards. This setting controls the approach that is used by Nsight Graphics in reflecting the application synchronization behavior.

Default - synchronizes on GetCompletedValue and Wait events. Never Sync - never performs synchronization. This option instructs replay to be free running, potentially leading to the highest frame rate.

Note that this is extremely likely to run into data hazards, so use with caution. Always sync - performance synchronization at every possible synchronization opportunity see above list of synchronization points. This will lead to the lowest frame rate, but introduces the most safety in replay. Use this setting as a debugging option if you suspect that there are synchronization options in the application replay. If turning this option on does lead to render-accuracy, please contact support to report this as a bug.

No sync on GetCompletedValue - applies all default settings, but turns off synchronization on GetCompletedValue. GetCompletedValue can be used as both a determination of what the current fence value is as well as an input into a control flow decision. Accordingly, because it may lead to control flow, it is synchronized on by default. You may use this setting if you are certain your application never uses GetCompletedValue as a control flow decision.

No Sync On Wait Corresponding To SetEventOnCompletion - This options turns off Synchronization on Win32 Wait calls. DXGI SyncInterval. Controls the SyncInterval value passed to the DXGI Present method. The default is to disable V-Sync to allow the debugger to collect valid real-time counters. Enable Revision Zero Data Collection. Controls the collection of revision zero e. pre-capture data during capture.

This is potentially an expensive operation, in both memory and processing time, and some applications can replay a single frame without explicitly storing these revisions. Memory - Save revision zero data in memory. This is the fastest, data correct option but can incur a large cost. Tempfile - Save revision zero data to temporary files, which Nsight will attempt to clean up no later than process termination.

This may avoid memory limits, but comes at a speed cost. Disabled - do not save any revision zero data. This is not generally correct but may work for some applications. Replay Captured ExecuteIndirect Buffer. When enabled, replays the application's captured ExecuteIndirect buffer instead of a replay-generated buffer. Consider this option if your application has rendering issues in replay that derive from a non-deterministic ExecuteIndirect buffer, for example one that is generated based off of atomic operations that can vary from frame-to-frame.

Report Force-Failed Query Interfaces. Controls whether failed query interfaces are reported to a user with a blocking message box. Nsight Graphics is an API debugger, and there may be some APIs that it does not yet support or does not yet know about. While this is valid by the COM spec, there are many applications that do not check the results of their QueryInterface calls, and as such, the application may assume success and will end up crashing as it dereferences a null pointer.

To combat this issue, Nsight Graphics will, by default, issue a blocking message box to inform the developer of the issue. This message box will offer the opportunity to understand issues that manifest at a later time or offer the indication that the application may need adjustment before a crash. If this operation interferes with normal operation, and otherwise would result in no issues, it may be disabled for the project. Report Unknown Objects. Controls whether unknown objects are reported to a user with a blocking message box.

Some applications pass objects that are unknown to Nsight Graphics. These objects may be indicative of an application bug, lack of support in the product's interception, or they may ultimately be innocuous. In many cases, such an unknown object may result in an analysis crash. To mitigate this issue, Nsight Graphics warns about this concern with a blocking message box. Support Cached Pipeline State. By default, Nsight Graphics will reject calls to create or load a cached pipeline state object.

Setting this option to true will enable support for these objects. Force Validation. Force the Vulkan validation layers to be enabled. This requires the LunarG Vulkan SDK to be installed. Validation Layers. Layers used when force enabling validation.

This option is only visible when 'Force Validation' is turned on. Enabling this option may lead to instability due to different allocation methods used by the driver.

This is necessary if the application is later binding addressable buffers but incorrectly excluded the flag on the associated memory. This results in larger capture but might address issues with out-of-bounds memory access. Enable Coherent Buffer Collection. Controls the monitoring and collection of mapped coherent buffer updates during capture. This is potentially an expensive operation and many applications can replay a single frame without actively monitoring these changes.

Use this option if your capture takes a long time but you do not straddle frames with coherent updates. Auto - Let Nsight Graphics decide. Typically this will default to Memory. Disabled - Do not save any revision zero data.

Allow Unsafe pNext Values. Allows the inspection of Vulkan structures with potentially dangerous pNext values. By default structures with no known extensions are skipped. Use Safe Object Lookup. Safe lookup are slower but may improve stability when using an unsupported extension. Auto - Fallback to safe mode when an unsupported extension is seen. By default we limit the object set to only objects used in the capture but in some cases a user might want to see all objects used in the application.

This might also help WAR a bug where the tool incorrectly prunes an object it shouldn't have. Only Active - Only include objects actively used in capture. All Resources - All active capture objects plus all buffers, images, pipelines, and shaders.

Reserve Heap Space. Amount of physical device heap space MB to automatically reserve for the frame debugger. Unweave Threads. For multi-threaded applications, attempts to remove excessive context switching by grouping thread events together.

To capture an application that uses wrapper libraries atop Vulkan, for example DXVK, set this setting to 'Yes' to ignore the wrapper library and capture the underlying Vulkan calls. When set to 'Auto', Nsight will attempt to auto-detect whether wrapper libraries should be ignored. Acceleration Structure Geometry Tracking. This option controls how geometry data is tracked for acceleration structures. There are tradeoffs between performance, accuracy, and robustness of any given approach.

The default setting of 'Auto' is most often implemented in terms of 'Deep Geometry Copy', which tries to match the most common application behavior whereby a deep copy is needed. For example, after building an acceleration structure, it is legal for an application to update or destroy the geometry buffers that were used in construction.

If you know that your application does not update or destroy buffers after construction, consider a 'Shallow Geometry Reference' option. Track Acceleration Structure Refits.

Controls whether acceleration structure refits should be tracked in addition to builds. Report Shallow Report Warnings. Controls whether warnings are issued for possible shallow reference validity issues. If an expert user knows that the original acceleration structure input data remains undisturbed they may silence warnings with this setting. Collect Geometry In GPU Memory. By default acceleration structure deep copy data is collected in system memory, for stability reasons.

Performance may be somewhat better doing the collection into GPU memory, but this puts pressure on the application's video memory budget. Enable Driver Instrumentation. Controls the enablement of capabilities that require driver support.

This effectively disables:. Disabling this option is the first and best option to try if you run into capture errors as it disambiguates problems quickly given the number of subsystems it turns off. Collect Shader Reflection. Controls the collection of all information reflected from shader objects.

This includes source code, disassembly, input attributes, resource associations, etc Note, dynamic shader editing is not available when this option is disabled. This option is useful if you suspect an error or incompatibility with a shader reflection tool such as D3DCompiler. dll or SPIRV-Cross. Collect SASS. Collect Line Tables. Enable creation of shader-to-PC line tables used by the shader profiler for source correlation.

Collect Hardware Performance Metrics. Enables the collection of performance metrics from the hardware. Ignore Incompatibilities. Nsight Graphics uses an incompatibility system to detect and report problems that are likely to interfere with the analysis of your application. By default, these incompatibilities are reported and the user is given the option of capturing despite them with an associated warning of the possibility of issues.

Some applications may have innocuous incompatibilities, however, and having to view this warning every time might be undesired. When this option is enabled, the frame will attempt to capture despite any incompatibilities. Use this option only when you are certain that the incompatibility will not impact your analysis.

Block on First Incompatibility. In some cases, these incompatibilities may be the first sign of an impending failure. Accordingly, being able to block on such a reported failure may aid in triaging and understanding a crash when running under Nsight Graphics. This option defaults to 'Auto' such that it only reports critical incompatibilities, allowing lesser incompatibilities so as not to interfere with expected operation.

It may be useful to toggle to 'Enable' if you encounter an application crash under Nsight Graphics to force an opportunity to investigate the crash. Enable Crash Reporting.

Enables the collection and reporting of crash data to help identify issues with the frame debugger. While a user is always prompted before a crash report is sent, this option is available to suppress these facilities entirely. This option allows that collection to be disabled entirely. Force Single-Threaded Capture.

Controls whether capture proceeds with concurrent threads or with serialized threads. Use this option if you suspect your application's multi-threading may be interfering with the capture process. Replay Thread Pause Strategy. Controls the strategy used in live analysis for pausing threads.

Auto - Use the default strategy, which may disable the Aggressive strategy for some applications. The Frame Debugger and Frame Profiler activities are capture-based activities. There are two classes of views in these activities — pre-capture views and post-capture views. Pre-capture views generally report real-time information on the application as it is running.

Post-capture views show information related to the captured frame and are only available after an application has been captured for live analysis. For an example of how to capture, follow the example walkthrough in How to Launch and Connect to Your Application.

The All Resources View allows you to see all of the available resources in the scene. This view shows a grid of all of the resources used by the application.

For graphical resources, these resources will be displayed graphically. For others, an icon is used to denote its type. When a resource is selected, a row of revisions will be shown for that resource.

Clicking on any revision will change the frame debugger event to the closest event that generated or had the potential of consuming that revision. Clicking the link below a resource, or double-clicking on the resource thumbnail, will open a Resource Viewer or Acceleration Structure View on that resource. There are a number of additional capabilities in this view. At the top of the All Resources view, you'll find a toolbar:.

Clone — makes a copy of the current view, so that you can open another instance. Lock — freezes the current view so that changing the current event does not update this view. This is helpful when trying to compare the state or a resource at two different actions. Red , Green , and Blue — toggles on and off specific colors. Alpha — enables alpha visualization. In the neighboring drop-down, you can select one of the following two options:. Flip Image — inverts the image of the resource displayed.

Below the toolbar is a set of buttons for high-level filtering of the resources based on type. Next to that, there is a drop-down menu that allows you to select how you wish to view the resources: thumbnails, small thumbnails, tiles, or details. If you select the Details view, you can sort the resources by the available column headings type, name, size, etc.

For high-level filtering, there are color coded buttons to filter based on resource type. All resource types are visible by default, and you can filter the resource list by de-selecting the button for the type you don't want to see. For example, if you'd like to see only textures, you can click the other buttons to de-select them and remove them from the list of resources.

You can choose from the drop-down of predefined filters to view only large resources, depth resources, unused resources, or resources that change in the frame. Selecting one of these will fill in the JavaScript string necessary for the requested filter, which is also useful as a basis to construct custom filters.

The Application HUD is a heads-up display which overlays directly on your application. You can use the HUD to capture a frame and subsequently scrub through its constituent draw calls on either the HUD or an attached host. All actions that occur either in the HUD or on the host — such as capturing a frame or scrubbing to a specific draw call — are automatically synchronized between the HUD and the host, and thus you can switch between using the HUD and host UI seamlessly as needed.

Running: Interact with your game or application normally, while the HUD shows an FPS counter. When you first start your application with Nsight Graphics , the HUD is in Running mode. This mode is most useful for viewing coarse GPU frame time in real-time while you run your application.

Frame Debugger: Once you have captured a frame, you can debug the frame directly in the Nsight Graphics HUD as well as from the host. The HUD allows you to scrub through the constituent draw calls of a frame, to view render targets with panning and zooming, and to examine specific values in those render targets. In this mode, your application can interact with the game or application normally, and the HUD shows frame-time overlaid on the scene.

There are two different methods to pause the application, which causes it to enter Frame Debugger mode. Press Target application capture hotkey , as mentioned above; or.

Go to the main toolbar in the Nsight Graphics UI and select Pause and Capture Frame. Once you have captured a frame, you can debug the frame directly in the HUD. While you can also debug the frame on the host, the HUD allows you to scrub through the constituent draw calls of a frame, to view render targets with panning and zooming, and to examine specific values in those render targets. The HUD scrubber can be clicked to navigate between events.

Additionally, the view has several controls to aid in your resource investigation. Navigate to a particular draw call in your frame. When the desired draw call is active, release the left mouse button. The geometry for the currently active draw call will be highlighted, as long as it is on screen. Pans and zooms the currently displayed render target.

Use the mouse wheel to zoom in to a particular portion of the render target. Cycles between the currently available render targets, depth targets, and stencil targets. Click the Select Render Target button on the HUD toolbar. A drop-down menu will appear, showing all valid choices for the current draw call.

Select the desired render target. Note that if a selected render target is not still active for a different draw call, the display will automatically switch to an active render target.

The API inspector is a common view to all supported APIs that offers an exhaustive look at all of the state that is relevant to a particular event to which the capture analysis is scrubbed. While the view is common, the state within it is particular to each API. See the section below that relates to your API of interest.

With API Inspector pages, there is a search bar that offers a quick way of finding the information you need on a particular page. The bar will indicate the number of matches in each page, and forward and back navigation buttons are provided for navigating between each match. Within an API Inspector page, there are many sections that can be expanded or collapsed to help narrow the information that is displayed to only the information you wish to see at that point in time.

While each section can be individually collapsed, the UI has buttons that allow for expanding or collapsing all elements in one click. Each page has the ability to be exported to structured data in a json format. This json data will include key value pairs of the data elements, as well as indirections that indicate the relationships between different kinds of data. This data is useful in cases where you may want to export data for persistence, or perhaps to run a diff between the data of different events.

The API Inspector view has an API-specific pipeline navigator that allows you to select a particular group of state within the GPU pipeline. From here, you can inspect the API state for each stage, including what textures and render targets are bound, or which shaders are in use in the related constants. IA —The Input Assembler shows the layout of your vertex buffers and index buffers.

VS — Shows all of the shader resource views and constant buffers bound to the Vertex Shader stage, as well as links to the HLSL source code and other shader information. HS — This shows all of the shader resource views and constant buffers bound to the Hull Shader stage, as well as links to the HLSL source code and other shader information.

DS — This shows all of the shader resource views and constant buffer bound to the Domain Shader stage, as well as links to the HLSL source code and other shader information.

GS — Shows all of the shader resource views and constant buffers bound to the Geometry Shader stage, as well as links to the HLSL source code and other shader information. RS — Shows the Rasterizer State parameters, including culling mode, scissor and viewport rectangles, etc.

PS — Shows all of the shader resource views, constant buffers, and render target views bound to the Pixel Shader stage, as well as links to the HLSL source code and other shader information.

OM — Shows the Output Merger parameters, including blending setup, depth, stencil, render target views, etc. CS — This shows all of the shader resource and unordered access views and constant buffers bound to the Compute Shader stage, as well as links to the HLSL source code and other shader information. The Input Assembler page shows the details of your vertex buffers and index buffers, the input layout of the vertices. In the constant buffer list, you can expand the buffer to see which HLSL variables are mapped to each entry, as well as the current values.

To enable resolution of HLSL variables, you must enable debug info when compiling the shader. See Shader Compilation for a discussion of the parameters required to prepare your shaders for optimal usage within Nsight Graphics. The Rasterizer State page displays parameters including culling mode, scissor and viewport rectangles, etc. The Output Merger page shows parameters including blending setup, depth, stencil, currently bound render target views, etc.

IA — The Input Assembler shows the layout of your vertex buffers and index buffers. The Input Assembler page shows the layout of your vertex buffers and index buffers, as well as the vertex declaration information.

The Rasterizer page displays render state settings, texture wrapping modes, and viewport information. The Output Merger page displays parameters such as blending setup, depth, and stencil states.

The Device page displays details about the architecture that was used. The Present page displays information about back buffers that were used. When using the Frame Debugger feature of Nsight Graphics , you may wish to do a deep dive into the specific draw calls in order to analyze your application further.

There are three different categories of API Inspector navigation. The first category is laid out like a "virtual GPU pipeline. Vtx Spec Vertex Specification — State information associated with your vertex attributes, vertex array object state, element array buffer, and draw indirect buffer. VS Vertex Shader — Vertex shader state, including attributes, samplers, uniforms, etc. TCS Tessellation Control Shader — Tessellation control shader state, including attributes, samplers, uniforms, control state, etc.

TES Tessellation Evaluation Shader — Tessellation evaluation shader state, including attributes, samplers, uniforms, evaluation state, etc. GS Geometry Shader — Geometry shader state, including attributes, samplers, uniforms, geometry state, etc. XFB Transform Feedback — Transform feedback state, including object state and bound buffers.

Raster Rasterizer — Rasterizer state, including point, line, and polygon state, culling state, multisampling state, etc. FS Fragment Shader — Fragment shader state, including attributes, samplers, uniforms, etc.

Pix Ops Pixel Operations — State information for pixel operations, including blend settings, depth and stencil state, etc. FB Framebuffer — State of the currently drawn framebuffer, including the default framebuffer, read buffer, draw buffer, etc. The object and pixel state inspectors section of the API Inspector consists of the following:.

Textures — Details about all of the currently bound textures and samplers, including texture and sampler parameters. Images — Details about all of the images currently bound to the image units.

Buffers — Details about all of the bound buffer objects, including size, usage, etc. Pixels — Current settings for pixel pack and unpack state.

Pipeline — Shows information about the currently bound pipeline object. Render Pass — Shows information about the current render pass object. FBO — Shows information related to the Frame Buffer Object that is associated with the current render pass. Viewport — Shows the current viewport and scissor information. VS — Shows all of the shader resource views and constant buffers bound to the Vertex Shader stage. TCS — Shows all of the shader resources associated with the Tessellation Control Shader stage.

TES — Shows all of the shader resources associated with the Tessellation Evaluation Shader stage. GS — Shows all of the shader resource views and constant buffers bound to the Geometry Shader stage. Raster — Shows the Rasterizer State parameters, including culling mode, scissor and viewport rectangles, etc. FS — Shows all of the shader resources associated with the Fragment Shader stage. Compute — This shows all of the shader resource and unordered access views and constant buffers bound to the Compute Shader stage.

Misc - Shows miscellaneous information associated with the instance, physical devices, and logical devices. The Pipeline page shows information about the currently bound pipeline object including: create info, pipeline layout, and push constant ranges. The Render Pass page shows information about the current render pass including: clear values, attachments operations, and sub-pass dependencies.

The Input Assembler page shows the layout of your vertex buffers and index buffers, as well as the vertex bindings and attribute information. The various shader pages display all of the shader modules, including: creation information, human readable SPIR-V source, current push constants, current bound descriptor sets, associated buffers, associated images and samples, and associated texel buffer views for this stage. The Raster page shows all rasterization information associated with pipeline object include: polygons modes, cull modes, depth bias, and line widths.

The Miscellaneous Information page shows information related to the instance, physical device s , logical device s , and queue s. The API Statistics View is a high-level view of important API calls, and includes information to help you see where GPU and CPU time is spent. The Batch Histogram view provides an intuitive way for the user to inspect the primitive's distribution across the draws.

The draws can be configurably divided into buckets and allow for disabling or enabling. This can be useful for the user who want to know which draw is heavy and how it affects the render target. Batch Histogram will display a histogram chart that contains divided buckets and can be configured by a few options.

Bucketing Mode — Determines how to divide the draws into buckets. Click Buckets then the corresponding events show in the table view. You can disable or enable the events by clicking Disable All or Enable All , also can be achieved by the check-box or right-click on the table items. Besides, the linkers on the table is directed to corresponding event in Events List.

The Current Target view is used to show the currently bound output targets. This can be useful because it focuses in on the bound output resources, rather than having to search for them in the All Resources view. Current Target will display thumbnails along the left pane for all currently bound color, depth, and stencil targets. This view will change as you scrub from event to event.

All of the thumbnails on the left can be selected to show a larger image on the right. You can also click the link below each to open the target in the Resource Viewer. The Events view shows all API calls in a captured frame. It also displays both CPU and GPU activity, as a measurement of how much each call "costs. Nsight also supports application-generated object and thread names in these columns; see Naming Objects and Threads for guidance on the supported methods for setting these names.

Clicking a hyperlink in the Events column will bring you to the API Inspector page for that draw call. You can select whether to view the events in a hierarchical or flat view. You can also sort the events by clicking on any of the available column headers.

The visibility of columns can be toggled by right-clicking on the table's header. By default some columns will be hidden if they offer no unique data e. single thread for the captured frame.

The events view can be filtered with both a quick filtering expression as well as a detailed configuration dialog. The filter input box offers a quick, regex-based match against events to find events of interest. Once entered, the view is automatically updated to match against the specified filter. The Configure button brings up a dialog for more advanced, as well as persistent, filtering of the events in the view.

Changes within this dialog will take immediate effect. There are three major classes of filters:. Filters set by the filter configuration dialog will persist from session to session.

Additionally, if multiple filter configurations are desired, you may save different named versions and recall them quickly by name. Filters entered into the main filter-input box are not persisted, as these filters are meant for quick filtering of the event data.

For entries that support regex syntax, the syntax is implemented with a perl-compatible regular expression language. Here are some examples of common tasks and the expressions that achieve them:. The Advanced Filters configuration dialog supports JavaScript syntax.

This enables complex evaluation of filtering expressions. The basic approach for JavaScript expressions is to match a particular column of data against an expression. From there, you can perform mathematical, logical, and text-matching expressions.

See some examples below to demonstrate the power and usage of these expressions:. While filtering, it is often desired to keep the context of certain items while you find others. To prevent an event from being filtered, Right Click the event and select Toggle Bookmark. If you wish to see the filtered results on the scrubber, you can select the tag button to the right of the filter toolbar, and a new row will appear in the Scrubber that displays your filtered events, allowing you to navigate those events in isolation.

On the Events page, you can use the hierarchical view to see a tree view of performance markers. The items listed in the drop-downs correspond with the nested child perf markers on the Scrubber. If you use the flat view on the Events page, the perf marker won't be nested, but you can hover your mouse over the color-coded field in the far left column, which allows you to view the details about that perf marker.

When an application uses multiple kinds of perf markers, the Marker API allows selecting the API to use for the display. This situation may arise if the application uses a middleware, for example, or mixes components with different marker strategies. To assist in navigation for an application using perf markers, the Events page shows a breadcrumb trail of the current perf marker stack.

Each of these sections, including the current event, are clickable and will navigate back to that location in the Event page. Go to the next perfmarker on the same level of the perfmarker stack. Go to the previous perfmarker on the same level of the perfmarker stack.

The Event Details view shows all parameters for the current event in a hierarchical tree structure that allows for searching. Because this window shows parameters for the current event, it will change as you navigate the scene.

If you wish to keep the parameters for comparison against another call, the view supports Clone and Lock capabilities. For events that reference API objects, the event details view provides a link to examine more information to that object in the Object Browser. The Geometry view takes the state of the Direct3D, OpenGL, or Vulkan machine, along with the parameters for the current draw call, and shows pre-transformed geometry.

There are two views into this data: a graphical view and a memory view. Left Click — Select the primitive or reset the selection if clicking at nothing. When selecting in the graphical viewer, the correlated rows in the memory table are also selected at the same time. Position — Specifies the vertex attribute to use for positional geometry data. Color — Specifies how to color the geometry. If Diffuse Color is selected, the selected diffuse color swatch will be used for coloring. If a vertex attribute is selected, the selected attribute will be used for per-vertex coloring.

Normal — Specifies the per-vertex normal. This selection applies when using a shade mode that specifies Normal Attribute or when rendering normal vectors. Clicking Configure in the bottom right corner of the Geometry View will open up the rendering options menu. Reset Camera — Resets the camera to its default orientation. By default, the viewer bounds all geometry with a bounding sphere for optimal orientation.

Zoom To Selected — Zoom the camera to the selected primitive. Render Mode — Determines how to render and raster geometry. Shade Mode — Specifies the lighting mode of the rendered image.

Selected Color Attribute : Shades with the specified color attribute. Flat Shading Using Generated Normals : Renders the geometry using flat shading with calculated normals. Flat Sharing Using Normal Attribute : Renders the geometry using flat shading with the specified Normal Attribute. Smooth Shading Using Normal Attribute : Renders the geometry using smooth shading with the specified Normal Attribute.

Render Normal Vectors — Renders the specified normal attribute as a vector pointing from each vertex. The vector may be colored by the Normal Color selection and may be scaled by the Normal Scale selection. The Memory tab of the Geometry View shows the contents of the vertex buffer, as interpreted by the current vertex or input attribute specification.

This view is useful for seeing the raw data of your draw call. An additional capability of this view is that it highlights invalid or corrupt vertices to streamline finding problematic data. Another useful feature is that the selection linkage to the graphical viewer, where selecting a memory row also selects the associated primitive. Index Buffer Order shows the vertices as indexed by the current index buffer and current draw call. Vertex Buffer Order shows the vertices as linearly laid out from the start of the vertex buffer and draw call specification.

The Object Browser view provides a list of all objects tracked for your frame, listed by name and by type. Beneath each object is a list of the properties and other metadata that Nsight tracks. This view is useful for finding objects that utilize a particular kind of property, for example a memory buffer with a particular flag. This view is also a destination for links provided by the Event Details and Event Viewer views.

This view supports Clone capabilities. Note, however, that this view captures fixed properties and metadata for each object at the end of frame. For APIs with mutable object properties, such as OpenGL, those properties will not be updated in coordination with scrubbing. As such, Lock capabilities are not applicable to this view. This view provides two panes side-by-side. The left-hand Objects pane provides the object list as well as their properties; the right-hand pane is context-sensitive and provides additional information about the object that is selected on the left-hand side.

The objects pane left-hand side provides several capabilities for filtering objects:. When the selected object has a specific viewer for viewing additional information about that type, a link to that specific viewer will be provided. For example, texture resources will provide a link to opening the selected texture in the Resource Viewer.

This section lists a table for the events in which an object is used. Each event will be tagged to indicate the Usage of that object READ or WRITE. Many API objects reference other objects. This section will list those objects, their type and relationship, as well as a link to more information on that related object.

The Range Profiler is a powerful tool that can help you determine how various portions of your frame utilize the GPU, and give you direction to optimize the rendering of your application. Once you have captured a frame, the Range Profiler displays your frame broken down into a collection of ranges, or groups of contiguous actions. For each range, you can see the GPU execution time, as well as detailed GPU hardware statistics across all of the units in the GPU.

The Range Profiler also includes unmatched data mining capabilities that allow you to group calls in the frame into ranges based on various criteria that you choose. The Range Profiler initially appears with the Range Selector at the top, followed by 5 default sections below that: Range Info, Pipeline Overview, SM Section, Memory, and User Metrics.

Under certain conditions, the Range Profiler pane may be disabled and display one of the following messages. You are running Nsight Graphics with a Kepler or lower GPU. This message is likely to occur when you are running Nsight Graphics on a non-MSHybrid laptop. The Range Selector provides an overview of the various rendering activities or passes in the scene.

You can see how long each portion of the frame takes, and compare the length or cost of the ranges on the timeline. When it first opens, the Range Selector will show ranges based on the performance markers you have instrumented your application with.

While performance markers are the best way to specify ranges and are utilized throughout the entire Nsight Graphics, UI, there are other facilities for creating ranges on the fly. The Range Selector Clicking the Add button will open a dialog that allows you to select what type of range you want to add. Program ranges — Actions that use the same shader program. Viewport ranges — Actions that render to the same viewport rectangle. User ranges — A range defined by you on the fly.

When you click on a range on the Scrubber portion, the other sections of the Range Profiler View will automatically update with that selected range's information. You can also click on a single action in the Scrubber to profile only that action. The Range Profiler comes with 5 default sections: Range Info , Pipeline Overview , SM Section , Memory , and User Metrics Section.

The section headers have a small triangle to the left of the name that allows you to collapse or open each one. The sections have a different look when collapsed vs open, mainly giving high level information when collapsed, and fuller data when opened.

Some of these sections also have combo boxes on the right side of the section header that allows you to choose the different visualizations available for displaying the data.

Finally, there are tooltips enabled on the metrics, which can give further details on what is being measured. The Range Info section gives you basic information about the selected range, split up with the draw calls on the left-hand side, and the compute dispatches on the right-hand side. For the draw calls, there is the number of calls in the range as well as the number of primitives and pixels rendered, both total and average per draw call.

On the compute side, there is similarly the number of calls, as well as thread and instruction counts, both total and average. When you open up the section, there is a table that has many of the metrics on the collapsed view, and adds some additional metrics for primitive counts, z-culling, etc.

The Pipeline Overview section gives an overview of how the selected ranges utilized the GPU. It does this by calculating a througput or Speed of Light or SOL for each unit in the pipeline. Speed of Light SOL : This metric gives an idea of how close the workload came to the maximum throughput of one of the sub-units of the GPU unit in question.

The idea is that, for the given amount of time the workload was in the GPU, there is a maximum amount of work that could be done in that unit. These values can include attributes fetched, fragments rasterized, pixels blended, etc. When you open the Pipeline Overview section, you are presented with a visual representation of the GPU pipeline, and color bars indicating the SOL or throughput for each unit represented. You can use the combo box on the right side of the header to display a table of metrics for every action in the currently selected range.

When collapsed, the SM Section has 2 main columns of data. On the left is a list of metrics about how utilized the SM shader units are in the GPU. SM Active tells you how many cycles the SM active and working during the measurement timeframe. If this value is low, this indicates that the workload is running only on a few SMs, either because of screen locality for pixel work or possibly that a compute dispatch was so small that it only occupied a small portion of the shader unit.

The SM Throughput for Active Cycles indicates the same value as the throughput or SOL value in the Pipeline Overview , but only measures it when the shader unit is active. Finally, the SM Occupancy value gives you a percentage of how full the shader unit was with warps.

Occupancy is key to hide latency, and things like register count and local memory usage in shaders can limit the number of warps. When there is not a warp eligible to issue an instruction, the SM is not able to do any work. Related to the occupancy value, the right hand side shows typical instruction stall reasons, including long scoreboard when the shader was waiting on a texture access , barrier when the shader was waiting for other warps to get to a given instruction , etc.

When you open the SM Section using the top left triangle, you will see a table that includes SM statistics on the left, including thread mix based on shader type, and all of the warp stall reasons on the right.

The Memory section displays information about the L2 cache and Frame Buffer or memory unit. Each interface has a maximum throughput for a given amount of time. The memory section shows the percentage of the subsystem interfaces utilized for the current range. The User Metrics Section gives the user the opportunity to explore all of the metrics that are available in the Range Profiler. It is initially collapsed, but when you click the upper left triangle, 2 tables will appear.

The left hand table lists the metrics with their name and a short description, as well as a check box to enable that metric for measurement. You can search for metrics of interest by using the filter box above the metric list. This will filter the metrics to a subset that matches the text you specify, which can be a GPU unit name, part of a metric value, etc.

When you select a metric, you will see a new entry appear in the right hand side table. Initially, you will likely see "…" appear for the value, which indicates that the tool is running the necessary experiments to retrieve the value. Once that is complete, the value will fill in. Above the metric value table is a Transpose button. You can use this to transpose the table from column to row major and back. The Range Profiler is user configurable via editing.

section text files or. py python scripts. section files and 1. py file. section files are able to display metrics only. py files can do everything the. section files can do albeit with different syntax , and can also define rules. More on that below. Each section can have a collapsed or Header view, and an expanded or Body view.

The default sections, in order of display, contain the following information:. The view can be modified on the fly by clicking the wrench icon in the toolbar. If you click Apply , the view will reload with your new choices, but the dialog will remain open for further editing. If you click OK, the view will similarly be updated, but the dialog will also be closed. Finally, Cancel will close the dialog and discard any changes that were not applied. If you make edits to the.

section or. py files and save them, the view will automatically detect the file change s and reload the view. When loading or reloading the sections, if there is an error detected, a new section will appear at the top of the view that contains any errors:. The Identifier field is used as a global identifier for the section file. The DisplayName is what you will see displayed in the header for the UI. You can keep both of these the same, or use different names if desired.

The next field is the Order. This is used to specify the display order of the sections in the view with lower numbers coming first and higher numbers coming last. Next is the Header portion. This is what you will see displayed when the section is in "collapsed" mode. You can put any number of Metric entries in this portion, and it will display the values for the Metric specified by Name with a user-friendly Label. Finally, there is the Body section. This is what will be displayed when the section is opened by clicking the triangle on the left-hand side of the section header.

There are some default bodies, including "Table," "BarChart," "HistogramChart," and "LineChart. The SMSection. section is an example of a table that displays a list of metrics. There are 2 special body types, GfxPipelineDiagram , and GfxMemoryDiagram , that will display specialized diagrams of the GPU pipeline and require a mapping from the Label to the metric used for determining the value to display.

If you wish to use them in your own section files, we suggest you copy them as is from their corresponding section files. Also, there is an additional special body type, GfxUserMetrics. The RangeInfo. py script is an example of specifying a section via Python. The syntax is a bit more complex, but the script allows you to also specify rules that will be evaluated that can be helpful for pointing out interesting metric values.

At the top of the RangeInfo. py file, you will see classes for Metric, SectionTable, BodyTableItem, etc. These are all helper classes used by the main class. In the RangeInfo, you will see a Header class, which is used to define what metrics will be displayed in the header portion of the UI, similar to the. section files. This takes a list of metric and label pairs. Below the Header is the Body class. This is similar to the Body in the.

section file and is used to put whatever type of body you would like to display. In the RangeInfo. py file, you will see a BodyItemTable that specifies the name of the table "" or blank in this case , the number of columns 2 , and a collection of metrics to display in the table. Finally, you will see more control code to initialize the class in the script, including the header and body portions, and load the section. Below that portion is a number of accessory functions to retrieve elements like the name and identifier of the section similar to the.

section file , and the "apply" function. This portion is used to define a rule. The top portion is more boiler plate code to gain access to the data for the currently selected range. Then, the rule samples two values: drawCount and dispatchCount. From there, it defines two rules. Then, as another example, if the drawCount is greater than the dispatchCount , it will say more draw calls than dispatches, and vice versa if the dispatchCount exceeds the drawCount. The Resource Viewer allows you to see all of the available resources in the scene.

This view is brought up by clicking resource links in any frame debugging view. The Resource Viewer is opened through links from resource thumbnails or entries in many Nsight views, for example from the API Inspector or All Resources View. The Graphical tab allows you to inspect the resource, pan using the left mouse button to click and drag, zoom using the mouse wheel, and inspect pixel values. Also, this is where you can save the resource to disk. If supported on your GPU and API, this is also where you can initiate a Pixel History session to get all of the contributing fragments for a given pixel.

When you have selected a buffer from the left pane, the Show Histogram button will be available on the right side of the Graphical tab, which allows for remapping the color channels for the resource being viewed. You can set the minimum and maximum cutoff values via the sliders under the histograms, or by typing in values in the Minimum and Maximum boxes.

The Luminance button allows you to visualize luminance instead of color values. The Normalize button can preset the minimum and maximum values to the extents of the data in the resource. The Axis drop-down changes between address memory offset and index array element views. The Offset entry limits the view to an offset within the given resource. The Extent entry limits the view to a maximum extent within the given resource. The Precision spin box controls the number of decimal places to show for floating point entries.

The Hex Display toggles between decimal base and hex base-8 display formats. Hash shows a hash value representative of the given memory resource within the current offset and extent.

This is useful for comparing memory objects or sub-regions. The Transpose button swaps the rows and columns of the data representation. The Configure button opens the Structured Memory Configuration dialog. At the top of the viewer, you'll find a toolbar:. Pixel history enables the automatic detection of the draw, clear, and data-update events that contributed to the change in a pixel's value.

In addition, pixel history can identify the fragments that failed to modify a particular texture target, allowing you to understand why a draw might be failing, such as whether you may have misconfigured API state in setting up your pipeline. To run a pixel history test, click the button and select a pixel to run the experiment on.

If you publish your app to Google Play, you should build and upload an Android App Bundle. Publishing multiple APKs is useful if you are not publishing to Google Play, but you must build, sign, and manage each APK yourself. Multiple APK support is a feature on Google Play that allows you to publish different APKs for your application that are each targeted to different device configurations. Each APK is a complete and independent version of your application, but they share the same application listing on Google Play and must share the same package name and be signed with the same release key.

This feature is useful for cases in which your application cannot reach all desired devices with a single APK. Android-powered devices may differ in several ways and it's important to the success of your application that you make it available to as many devices as possible. Android applications usually run on most compatible devices with a single APK, by supplying alternative resources for different configurations for example, different layouts for different screen sizes and the Android system selects the appropriate resources for the device at runtime.

In a few cases, however, a single APK is unable to support all device configurations, because alternative resources make the APK file too big or other technical challenges prevent a single APK from working on all devices. To help you publish your application for as many devices as possible, Google Play allows you to publish multiple APKs under the same application listing.

Google Play then supplies each APK to the appropriate devices based on configuration support you've declared in the manifest file of each APK.

Currently, these are the only device characteristics that Google Play supports for publishing multiple APKs as the same application. The concept for using multiple APKs on Google Play is that you have just one entry in Google Play for your application, but different devices might download a different APK.

This means that:. Which devices receive each APK is determined by Google Play filters that are specified by elements in the manifest file of each APK.

However, Google Play allows you to publish multiple APKs only when each APK uses filters to support a variation of the following device characteristics:. For example, when developing a game that uses OpenGL ES, you can provide one APK for devices that support ATI texture compression and a separate APK for devices that support PowerVR compression among many others.

For example, you can provide one APK that supports small and normal size screens and another APK that supports large and xlarge screens. To learn more about generating separate APKs based on screen size or density, go to Build Multiple APKs. Consider the following best practices to support all screen sizes: The Android system provides strong support for applications to support all screen configurations with a single APK.

You should avoid creating multiple APKs to support different screens unless absolutely necessary and instead follow the guide to Supporting Multiple Screens so that your application is flexible and can adapt to all screen configurations with a single APK. However, because the android:xlargeScreens attribute was added in Android 2.

Using both increases the chances that you'll introduce an error due to conflicts between them. For help deciding which to use, read Distributing to Specific Screens. If you can't avoid using both, be aware that for any conflicts in agreement between a given size, "false" will win. For example, you can provide one APK for devices that support multitouch and another APK for devices that do not support multitouch.

See Features Reference for a list of features supported by the platform. You can use both the android:minSdkVersion and android:maxSdkVersion attributes to specify support for different API levels.

For example, you can publish your application with one APK that supports API levels 16 - 19 Android 4. To learn how to build separate APKs that each target a different range of APIs, go to Configure Product Flavors.

If you use this characteristic as the factor to distinguish multiple APKs, then the APK with a higher android:minSdkVersion value must have a higher android:versionCode value. This is also true if two APKs overlap their device support based on a different supported filter. This ensures that when a device receives a system update, Google Play can offer the user an update for your application because updates are based on an increase in the app version code. This requirement is described further in the section below about Rules for multiple APKs.

You should avoid using android:maxSdkVersion in general, because as long as you've properly developed your application with public APIs, it is always compatible with future versions of Android. If you want to publish a different APK for higher API levels, you still do not need to specify the maximum version, because if the android:minSdkVersion is "16" in one APK and "21" in another, devices that support API level 21 or higher will always receive the second APK because its version code is higher, as per the previous note.

Some native libraries provide separate packages for specific CPU architectures, or Application Binary Interfaces ABIs. Instead of packaging all available libraries into one APK, you can build a separate APK for each ABI and include only the libraries you need for that ABI. To learn more about generating separate APKs based on target ABI, go to Build Multiple APKs. Other manifest elements that enable Google Play filters —but are not listed above—are still applied for each APK as usual.

However, Google Play does not allow you to publish separate APKs based on variations of those device characteristics. Thus, you cannot publish multiple APKs if the above listed filters are the same for each APK but the APKs differ based on other characteristics in the manifest or APK.

Before you publish multiple APKs for your application, you need to understand the following rules:. That is, each APK must declare slightly different support for at least one of the supported Google Play filters listed above.

Usually, you will differentiate your APKs based on a specific characteristic such as the supported texture compression formats , and thus, each APK will declare support for different devices.

However, it's OK to publish multiple APKs that overlap their support slightly. When two APKs do overlap they support some of the same device configurations , a device that falls within that overlap range will receive the APK with a higher version code defined by android:versionCode. This is true only when either: the APKs differ based only on the supported API levels no other supported filters distinguish the APKs from each other or when the APKs do use another supported filter, but there is an overlap between the APKs within that filter.

This is important because a user's device receives an application update from Google Play only if the version code for the APK on Google Play is higher than the version code of the APK currently on the device.

This ensures that if a device receives a system update that then qualifies it to install the APK for higher API levels, the device receives an application update because the version code increases. Note: The size of the version code increase is irrelevant; it simply needs to be larger in the version that supports higher API levels. Failure to abide by the above rules results in an error on the Google Play Console when you activate your APKs—you will be unable to publish your application until you resolve the error.

There are other conflicts that might occur when you activate your APKs, but which will result in warnings rather than errors. Warnings can be caused by the following:. Note: If you're creating separate APKs for different CPU architectures, be aware that an APK for ARMv5TE will overlap with an APK for ARMv7. That is, an APK designed for ARMv5TE is compatible with an ARMv7 device, but the reverse is not true an APK with only the ARMv7 libraries is not compatible with an ARMv5TE device.

When such conflicts occur, you will see a warning message, but you can still publish your application. Once you decide to publish multiple APKs, you probably need to create separate Android projects for each APK you intend to publish so that you can appropriately develop them separately. You can do this by simply duplicating your existing project and give it a new name.

Alternatively, you might use a build system that can output different resources—such as textures—based on the build configuration. Tip: One way to avoid duplicating large portions of your application code is to use a library project.

A library project holds shared code and resources, which you can include in your actual application projects. When creating multiple projects for the same application, it's a good practice to identify each one with a name that indicates the device restrictions to be placed on the APK, so you can easily identify them. Note: All APKs you publish for the same application must have the same package name and be signed with the same certificate key.

Be sure you also understand each of the Rules for multiple APKs. Each APK for the same application must have a unique version code , specified by the android:versionCode attribute.

You must be careful about assigning version codes when publishing multiple APKs, because they must each be different, but in some cases, must or should be defined in a specific order, based on the configurations that each APK supports. An APK that requires a higher API level must usually have a higher version code. For example, if you create two APKs to support different API levels, the APK for the higher API levels must have the higher version code.

This ensures that if a device receives a system update that then qualifies it to install the APK for higher API levels, the user receives a notification to update the app. For more information about how this requirement applies, see the section above about Rules for multiple APKs.

You should also consider how the order of version codes might affect which APK your users receive either due to overlap between coverage of different APKs or future changes you might make to your APKs.

For example, if you have different APKs based on screen size, such as one for small - normal and one for large - xlarge, but foresee a time when you will change the APKs to be one for small and one for normal - xlarge, then you should make the version code for the large - xlarge APK be higher.

That way, a normal size device will receive the appropriate update when you make the change, because the version code increases from the existing APK to the new APK that now supports the device. Also, when creating multiple APKs that differ based on support for different OpenGL texture compression formats, be aware that many devices support multiple formats.

Because a device receives the APK with the highest version code when there is an overlap in coverage between two APKs, you should order the version codes among your APKs so that the APK with the preferred compression format has the highest version code. For example, you might want to perform separate builds for your app using PVRTC, ATITC, and ETC1 compression formats.

If you prefer these formats in this exact order, then the APK that uses PVRTC should have the highest version code, the APK that uses ATITC has a lower version code, and the version with ETC1 has the lowest.

Thus, if a device supports both PVRTC and ETC1, it receives the APK with PVRTC, because it has the highest version code. In case Google Play Store is unable to identify the correct APK to install for a target device, you may want to also create a universal APK that includes resources for all the different device variations you want to support.

If you do provide a universal APK, you should assign it the lowest versionCode. Because Google Play Store installs the version of your app that is both compatible with the target device and has the highest versionCode , assigning a lower versionCode to the universal APK ensures that Google Play Store tries to install one of your other APKs before falling back to the larger universal APK.

In order to allow different APKs to update their version codes independent of others for example, when you fix a bug in only one APK, so don't need to update all APKs , you should use a scheme for your version codes that provides sufficient room between each APK so that you can increase the code in one without requiring an increase in others.

You should also include your actual version name in the code that is, the user visible version assigned to android:versionName , so that it's easy for you to associate the version code and version name. Note: When you increase the version code for an APK, Google Play will prompt users of the previous version to update the application.

Thus, to avoid unnecessary updates, you should not increase the version code for APKs that do not actually include changes. We suggest using a version code with at least 7 digits: integers that represent the supported configurations are in the higher order bits, and the version name from android:versionName is in the lower order bits. For example, when the application version name is 3. The first two digits are reserved for the API Level 4 and 11, respectively , the middle two digits are for either screen sizes or GL texture formats not used in these examples , and the last three digits are for the application's version name 3.

Figure 1 shows two examples that split based on both the platform version API Level and screen size. Figure 1. A suggested scheme for your version codes, using the first two digits for the API Level, the second and third digits for the minimum and maximum screen size 1 - 4 indicating each of the four sizes or to denote the texture formats and the last three digits for the app version.

This scheme for version codes is just a suggestion for how you should establish a pattern that is scalable as your application evolves. In particular, this scheme doesn't demonstrate a solution for identifying different texture compression formats. One option might be to define your own table that specifies a different integer to each of the different compression formats your application supports for example, 1 might correspond to ETC1 and 2 is ATITC, and so on.

You can use any scheme you want, but you should carefully consider how future versions of your application will need to increase their version codes and how devices can receive updates when either the device configuration changes for example, due to a system update or when you modify the configuration support for one or several of the APKs.

Content and code samples on this page are subject to the licenses described in the Content License. Platform Android Studio Google Play Jetpack Kotlin Docs Games. App Basics. App resources.

Battery and power. Getting started. Play Install Referrer Library. However, it is often convenient to make spacecraft trajectory information available through the same mechanism, especially for use by space-based telescopes as observing sites. NET Standard 2. You can substitute the call to the ReadOnlyDatabase with a call to read from a file of choice to load the alternate texture.

Categories:

• Binary Options
• Forex Brokers
• Forex
• Binary Options online
• Forex Bitcoin