FIELD NOTE / 2026.09.123 MIN READ / 5 SOURCES

Android, Dalvik, and the Open Mobile Application Platform

Android paired an alliance-driven mobile platform, Linux process isolation and Dalvik's DEX runtime with an SDK released before the first commercial device shipped.

Android was announced as a platform rather than a single Google phone

In November 2007 Google and partners announced the Open Handset Alliance and Android as a mobile platform intended for many devices, not one vertically integrated handset. Google’s SDK announcement explicitly followed the alliance announcement and invited outside developers into the platform.[1]

The project included an operating system, application framework and development tools that hardware makers and software developers could build around.

The early SDK invited developers before the first commercial device

On November 12, 2007 Google released an early Android SDK so developers could build, test and debug applications in an emulator before consumer phones shipped.[1]

This was an ecosystem-building decision: application development could begin while hardware and interface details were still evolving.

The emulator separated software adoption from device availability

Developers did not need an unreleased phone in order to learn the APIs. The SDK made the platform visible as software before it became visible as retail hardware.

Android used Linux processes as an important security boundary

Google’s early developer discussion emphasized that Android applications run with Linux process and user isolation and that the virtual machine was not solely responsible for application security.[2]

This architecture connected a managed application environment to operating-system mechanisms already proven in Unix-like systems.

Dalvik was created specifically for Android’s constrained environment

The Android Open Source Project states that Dalvik was created specifically for Android and executed the Dalvik Executable, or DEX, bytecode format.[3]

Unlike a conventional desktop Java VM running ordinary class files, Android transformed application bytecode into a format designed around mobile storage and runtime constraints.

DEX made the application binary a platform contract

DEX reorganized application classes and constants into a compact executable representation. That format could remain stable even when the runtime implementation later changed.

The first public DEX formats appeared during the 2007 previews

AOSP’s DEX specification records format version 009 in the M3 releases of November–December 2007 and version 013 in the M5 releases of early 2008.[4]

This provides a concrete software-archaeology trail from prerelease SDKs into the shipping platform.

The T-Mobile G1 connected the software platform to a commercial device

In October 2008 Google released the Android source code as the T-Mobile G1 prepared to go on sale.[5]

The open-source release let handset makers, researchers and developers inspect and modify a complete mobile stack rather than only consume a closed SDK.

Open source referred to the platform, not every Google application

Android’s open platform and Google’s proprietary service applications were distinct layers. That distinction became important to the ecosystem’s later governance.

ART later replaced Dalvik without discarding DEX

Android Runtime, or ART, eventually replaced Dalvik as the managed runtime, but AOSP documents compatibility around DEX bytecode so applications developed for the earlier model could continue to work.[3]

This illustrates the value of a stable intermediate format: implementation machinery can change beneath an application contract.

The application framework mattered as much as the VM

Activities, services, intents and content providers gave Android developers higher-level components above Dalvik. The runtime enabled portability, while the framework defined much of the application model.

Why Android and Dalvik reshaped mobile software platforms

Android combined an alliance model, early developer SDK, Linux-based process isolation and a purpose-built managed runtime into one extensible mobile stack.[1][3]

The result differed from Palm and Symbian in architecture and governance, but continued the same historical problem: how to give third-party developers a stable programming platform across rapidly changing mobile hardware.

RESEARCH / PROVENANCE

Works Cited

5 SOURCES
  1. 01
  2. 02
  3. 03
  4. 04
  5. 05

CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.

Contribute / Corrections

Improve the record.

Use this moderated submission form to suggest a correction, provide a source, challenge a priority claim or identify a missing contributor. Submissions are treated as research leads, not automatically published comments.

Submit a research lead

Please do not submit confidential material or claims you cannot support.