A native app is a software application developed specifically for a particular operating system or hardware platform, using the programming languages, development tools, application programming interfaces and platform conventions intended for that environment. Common examples include applications built specifically for Android, iOS, Windows, macOS or Linux. A native mobile application is normally installed on the device and executes using the platform's native runtime and APIs rather than primarily depending on a browser.
The term native refers to the application's close relationship with the target platform, not simply to the fact that it is installed. For example, an iOS application written in Swift or Objective-C using Apple's SDKs is native to iOS, while an Android application written in Kotlin or Java using Android's APIs is native to Android. A native application is consequently optimised around the capabilities, constraints and conventions of its intended platform.
Native development gives an application direct access to platform-specific APIs and hardware capabilities exposed by the operating system. Depending on permissions and platform restrictions, a native application can interact with features such as cameras, microphones, GPS, Bluetooth, biometric authentication, notifications, sensors, graphics processors, local storage, contacts and background services. Native frameworks also provide platform-specific mechanisms for user-interface rendering, networking, accessibility, security and lifecycle management.
This can produce strong performance and responsive interaction because the application can use APIs and execution models designed specifically for the target environment. It does not mean that every native application is automatically fast or efficient; poor algorithms, excessive resource consumption, inefficient rendering and badly designed network operations can make a native application slow just as they can in other software architectures.
A native app normally follows the design conventions of its platform. On mobile platforms, this includes expected navigation patterns, permission prompts, notification behaviour, accessibility features and interaction models. Native user-interface frameworks can provide controls that behave consistently with the operating system and automatically integrate with platform features such as dynamic text sizing, dark mode, screen readers and system settings. Native applications can also respond to operating-system lifecycle events, including suspension, termination and restoration. These characteristics can improve the consistency of the user experience, although developers must maintain platform-specific code and adapt applications as operating systems, devices and APIs evolve.
Native applications are commonly distinguished from cross-platform, hybrid and web applications. A cross-platform application attempts to share substantial code across multiple operating systems while producing applications for those environments. A hybrid application traditionally combines web technologies with a native wrapper or runtime. A web application executes primarily through a web browser. A native application instead uses the target platform's own development environment and APIs directly.
The boundaries can be less absolute in modern frameworks because some cross-platform technologies can compile to or generate platform-specific native components, and some applications combine native modules with shared code. Consequently, "native" describes the implementation relationship with the platform rather than a guarantee that every line of source code is platform-specific.
Native development has historically involved separate technology stacks for different platforms. For example, iOS development has traditionally centred on Apple's SDKs and languages such as Objective-C and Swift, while Android development has used Android's SDK with Java and Kotlin. Desktop platforms have their own native frameworks, APIs and languages, such as Win32, Windows App SDK, Cocoa and AppKit. Developers can also use native development environments for specialised platforms such as game consoles, embedded systems and smart televisions. Platform-specific development enables detailed control but usually increases development and maintenance work when the same application needs to support several operating systems. Each version may require separate testing, deployment, accessibility verification and adaptation to platform-specific behaviours.
Native applications can provide strong access to platform security models. They can use operating-system permission systems, secure storage facilities, hardware-backed key protection and platform authentication mechanisms where supported. Mobile operating systems normally isolate applications using sandboxing and restrict access to sensitive resources unless appropriate permissions or entitlements are available. Native applications must still follow platform security rules and can contain vulnerabilities such as insecure storage, injection flaws, improper authentication or unsafe handling of sensitive data. Native status therefore does not itself make an application secure. Security depends on the application's architecture, code, dependencies, permissions, update mechanism and interaction with external services.
Native apps can have disadvantages as well as technical strengths. Supporting multiple platforms separately can require more developers, more source code, more testing and more release management. A feature implemented on one platform may need a separate implementation on another. Platform-specific expertise is also required, and changes to operating-system APIs can create maintenance work. Native applications may additionally require users to download and install updates, although modern app stores can automate much of this process. These costs can be justified when performance, hardware integration, platform-specific functionality or highly integrated user experiences are important requirements.
The concept of native software has existed since early computing, when applications were naturally written for specific operating systems and processor architectures. Modern native development is more abstract because compilers, runtimes and SDKs hide many hardware details, but the underlying principle remains platform-specific integration. A native app is therefore best understood as an application designed and built to operate within the native software environment of a particular platform. Its principal characteristics are direct use of platform APIs, platform-specific packaging and deployment, close integration with operating-system capabilities and the ability to exploit features that may not be equally available through browser-based or abstraction-based technologies.
