Things native apps do well:

- Run offline

- Access large files stored locally

- Start from the command line or from clicking buttons on your desktop

- Use graphics cards and other peripherals

- Run quickly

- Tune performance to your platform

- Come pre-installed on your system

- Exist for all time

- .. and don't require servers and money to host them

- Security is pretty easy to solve

- Coded in pretty much any language

- Interop with other native software

- Run in windows or fullscreen

- Easily convince people that they ought to be purchased

- Obfuscate their functionality from users [important for, say, video games]

- Handle large amounts of data without network bandwidth constraints

- Standardized UX, so it's less easy to screw up.

- .. and when you do get an app running, you get a lot more UX for free [well, depending on what you're doing]

Things webapps do well (and sometimes get for free) that native apps do really, really badly:

- Save data across multiple systems

- Allow you to login anywhere

- Get off the ground with a UI + basic functionality in O(1) lines of code.

- Receive updates from their maintainer

- Run multiple instances at once with a single click

- Are completely sandboxed from other apps (app freezes? just refresh the page)

- And are sandboxed enough that you can pretty much trust them (barring tricking you into downloading viruses / exploits, etc, you don't have much to fear from a website,, at least compared to running untrusted executables)

- Live in easily manageable tabs

- Are easily augmented using scripts (Greasemonkey, etc) or simple scripting (JS in the URL bar) or plugins (browser extensions, etc)

- Are globally namespaced and addressable and bookmarkable. Every webapp runs in the same container so other programs can manage them in a uniform way: via bookmarks, hyperlinks, etc.

- Support an intuitive format for entry points into the internals of an the application, via URLs. Compare to: save files for a video game.

- Must forcibly reveal their source code (except for Flash & similar plugins) to the client, so it's hard to deceive [technically savvy] users.

- .. and are largely open source by default (except for Flash & similar plugins)

- .. which means anyone, even someone who's never coded in their life, can learn to peek under the covers and see how things work.

- Use global identities (logging in with Google/FB/Twitter/etc) and sometimes global configurations (Google cloud sync, etc)

- Elegantly support collaboration (send someone a Google Doc link and you're done)

- Standardized ways of handling authentication and security
- Default implementations for hotkeys, linking, text editing, scrollbars, image insertion, etc.

- Default implementations for caching of resources, shared libraries, and asynchronous messaging [sort-of]
- I'm sure there's lots more.

It seems to me that web browsers accidentally solved a very general problem with a very specific solution.

--

The problem: how do I run software that's dynamically loaded over the Internet with minimal barriers to my users?

(Well, initially, it was 'how do I display text from the Internet to users', but we've moved passed that.)

The solution: I'll build an application that interprets a single programming language (Javascript) with a single standard UI language (HTTP+CSS) and supports a global namespace of all other apps (DNS,etc) and allows data to be encoded in resource identifiers (URLS) and maintains state across sites and across sessions (cookies), and I'll call it a Web Browser.

This relatively arbitrary solution got a lot of things for free, but it left us with a lot of implicit constraints that divided the line between web and native applications. Ever since then everyone has been trying to break back out: adding tabs, isolating tab processes, supporting extensions, embedding Java, embedding Flash, supporting SVG and Canvas and WebGL, etc. We're still largely trapped in the interpreted-Javascript world.. but Dart gets points for trying, and alternative languages/paradigms (stronger-typed variants like TypeScript, from different programming paradigms like React, and from entirely different languages (asm.js, GWT..)), are gaining traction. Meanwhile, AWS S3/Lambda/etc, Dropbox-based storage, Google cloud sync'd settings, or global credentials via Twitter/FB/Google/Etc.. these are all reducing the amount of work you have to do to build and maintain a simple app in a website.

I wish I could use Dropbox or Google Docs as my 'filesystem', if that made sense, or use the local filesystem as my filesystem, if that made sense instead; I wish I could use local keyfiles or global accounts at will, or build low-level compiled libraries and mix them with deployed, interpreted website code at will. I also wish my window manager and my tab manager were the same application, and my Omni-bar searched my desktop and the entire internet, and my stickynotes were synchronized on any computer I log in to. And I also wish I could write a native (but sandboxed, except for the permissions I grant it) application with a UI that interops with my OS and other programs by simply writing 10 lines of code and then saving the file with a .html extension. Basically, I don't particularly want to write native apps; I just want to casually slide back and forth over the line between native and web.