diff --git a/docs/markdown/Android-module.md b/docs/markdown/Android-module.md
new file mode 100644
index 000000000000..a9ed7baad721
--- /dev/null
+++ b/docs/markdown/Android-module.md
@@ -0,0 +1,54 @@
+# Android module
+
+This module provides mechanisms to build applications on Android.
+
+## Usage
+
+To use this module, just do: **`android = import('android')`**. The
+following functions will then be available as methods on the object
+with the name `android`. You can, of course, replace the name
+`android` with anything else.
+
+### android.generate_apk()
+
+```
+    android.generate_apk(manifest: string | File | CustomTarget | CustomTargetIndex | GeneratedList,
+                         sources ... : string | File | CustomTarget | CustomTargetIndex | GeneratedList | Jar,
+                         app_id: string | None = None,
+                         target_sdk: int | None = None,
+                         min_sdk: int | None = None,
+                         resources: [](string | File | CustomTarget | CustomTargetIndex | GeneratedList) = [],
+                         install: bool = false,
+                         install_dir: string | None = None,
+                         install_tag: string | None = None,
+                         ): CustomTarget
+```
+
+This function generates an Android APK file based on the manifest and
+sources passed to it.
+
+**DO NOT** use this for deploying production applications. The format
+this effectivly produces (arch-split APKs) is not accepted by Google
+anymore and the new application bundle format is entirely incompatible
+with the way meson works. For production applications, look instead at
+[Building Android apps with native code using Meson](https://nibblestew.blogspot.com/2025/10/building-android-apps-with-native-code.html).
+
+* `manifest`: The AndroidManifest.xml file describing your application
+* `sources`: java source files are jars that compose your application
+* `app_id`: the application package identifier (typically a domain you
+            control in big endian format). This is optional if the
+            manifest already contains a package id.
+* `target_sdk`: The SDK version your application targets
+* `min_sdk`: The lowest SDK version your application still supports
+* `resources`: Files that will be added as resources to the APK (i.e.
+               drawables, layouts, etc.). *Note:* the directory each
+               file resides in has to match the resource group that
+               it is a part of.
+* `install`: if true, install the apk file
+* `install_dir`: location to install the apk file to
+* `install_tag`: A string used by the `meson install --tags` command
+                 to install only a subset of the files.
+
+Returns the target that produces the APK
+
+*Added 1.11.0*
diff --git a/docs/sitemap.txt b/docs/sitemap.txt
index a71e954424ff..42287bd07078 100644
--- a/docs/sitemap.txt
+++ b/docs/sitemap.txt
@@ -37,6 +37,7 @@ index.md
 		Disabler.md
 		Code-formatting.md
 		Modules.md
+			Android-module.md
 			CMake-module.md
 			Codegen-module.md
 			Cuda-module.md
diff --git a/docs/theme/extra/templates/navbar_links.html b/docs/theme/extra/templates/navbar_links.html
index ac4a6fe1052c..05b048755901 100644
--- a/docs/theme/extra/templates/navbar_links.html
+++ b/docs/theme/extra/templates/navbar_links.html
@@ -6,6 +6,7 @@
   </a>
   <ul class="dropdown-menu" id="modules-menu">
     @for tup in [ \
+            ("Android-module.html","Android"), \
             ("CMake-module.html","CMake"), \
             ("Codegen-module.html","Codegen"), \
             ("Cuda-module.html","CUDA"), \
diff --git a/mesonbuild/modules/__init__.py b/mesonbuild/modules/__init__.py
index 3153027b9463..1d46a866554c 100644
--- a/mesonbuild/modules/__init__.py
+++ b/mesonbuild/modules/__init__.py
@@ -79,11 +79,13 @@ def find_program(self, prog: T.Union[mesonlib.FileOrString, T.List[mesonlib.File
                      required: bool = True,
                      version_func: T.Optional[ProgramVersionFunc] = None,
                      wanted: T.Union[str, T.List[str]] = '', silent: bool = False,
+                     search_dirs: T.Optional[T.List[str]] = None,
                      for_machine: MachineChoice = MachineChoice.HOST) -> Program:
         if not isinstance(prog, list):
             prog = [prog]
         return self._interpreter.find_program_impl(prog, required=required, version_func=version_func,
-                                                   wanted=wanted, silent=silent, for_machine=for_machine)
+                                                   wanted=wanted, silent=silent, search_dirs=search_dirs,
+                                                   for_machine=for_machine)
 
     def find_tool(self, name: str, depname: str, varname: str, required: bool = True,
                   wanted: T.Optional[str] = None, native: bool = True) -> Program:
diff --git a/mesonbuild/modules/android.py b/mesonbuild/modules/android.py
new file mode 100644
index 000000000000..ce938bebf218
--- /dev/null
+++ b/mesonbuild/modules/android.py
@@ -0,0 +1,469 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026  Florian Leander Singer <sp1rit@disroot.org>
+
+import typing as T
+import os
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo
+from .. import build
+from .. import mlog
+from ..build import CustomTarget, Jar
+from ..interpreter.type_checking import INSTALL_KW, INSTALL_DIR_KW, INSTALL_TAG_KW, NoneType
+from ..interpreterbase import FeatureNew
+from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, typed_kwargs, typed_pos_args
+from ..mesonlib import File, MachineChoice, MesonException
+
+if T.TYPE_CHECKING:
+    from pathlib import Path
+    from typing_extensions import TypedDict
+
+    from . import ModuleState
+    from ..build import GeneratedTypes
+    from ..compilers import Compiler
+    from ..interpreter.interpreter import Interpreter
+    from ..programs import Program
+
+APK_SOURCES_VARARGS = (str, File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, Jar)
+if T.TYPE_CHECKING:
+    ApkSourcesType = T.List[T.Union[str, File, GeneratedTypes, Jar]]
+
+    class GenerateApk(TypedDict):
+        app_id: T.Optional[str]
+        target_sdk: T.Optional[int]
+        min_sdk: T.Optional[int]
+        resources: T.List[T.Union[str, File, GeneratedTypes]]
+        install: bool
+        install_dir: T.Optional[str]
+        install_tag: T.Optional[str]
+
+@dataclass
+class JavaLinkingTools:
+    jmod: 'Program'
+    jlink: 'Program'
+
+@dataclass
+class JavaTools:
+    java_home: 'Path'
+    javac: 'Compiler'
+    linking: T.Optional[JavaLinkingTools]
+
+@dataclass
+class AndroidTools:
+    aapt2: 'Program'
+    d8: 'Program'
+    zipalign: 'Program'
+    apksigner: 'Program'
+
+
+class AndroidModule(ExtensionModule):
+
+    INFO = ModuleInfo('android')
+
+    # TODO: maybe get from property?
+    android_home = '/home/florian/Android/Sdk'
+
+    def __init__(self, interpreter: 'Interpreter'):
+        super().__init__(interpreter)
+        self.methods.update({
+            'generate_apk': self.generate_apk,
+        })
+
+        self.java_tools: T.Optional[JavaTools] = None
+        self.android_tools: T.Optional[AndroidTools] = None
+        self.android_images: T.Dict[int, T.Tuple[str, CustomTarget]] = {}
+
+    def _get_java_linking_tools(self, state: 'ModuleState', java_home: 'Path') -> JavaLinkingTools:
+        jmod = state.find_program('jmod', search_dirs=[str(java_home.joinpath('bin'))])
+        jlink = state.find_program('jlink', search_dirs=[str(java_home.joinpath('bin'))])
+        return JavaLinkingTools(jmod, jlink)
+
+    def get_java_tools(self, state: 'ModuleState', linking: bool) -> JavaTools:
+        if self.java_tools is not None:
+            if not linking or self.java_tools.linking is not None:
+                return self.java_tools
+            else:
+                self.java_tools.linking = self._get_java_linking_tools(state, self.java_tools.java_home)
+                return self.java_tools
+
+        if 'java' not in state.environment.coredata.compilers[MachineChoice.BUILD]:
+            raise MesonException('Unable to find java compiler in project')
+        javac = state.environment.coredata.compilers[MachineChoice.BUILD]['java']
+        java_home = state.environment.properties[MachineChoice.BUILD].get_java_home()
+        if java_home is None:
+            raise MesonException('TODO: factor the complex java_home determination code from dependencies.dev into a shared function')
+        linking_tools = self._get_java_linking_tools(state, java_home) if linking else None
+        self.java_tools = JavaTools(java_home, javac, linking_tools)
+        return self.java_tools
+
+    def get_android_tools(self, state: 'ModuleState') -> AndroidTools:
+        if self.android_tools is not None:
+            return self.android_tools
+
+        aapt2 = state.find_program('aapt2')
+        d8 = state.find_program('d8')
+        zipalign = state.find_program('zipalign')
+        apksigner = state.find_program('apksigner')
+        self.android_tools = AndroidTools(aapt2, d8, zipalign, apksigner)
+        return self.android_tools
+
+    # Processes a Jar containing the system module classes into a JDK
+    # Image, for use via the --system option of javac and other
+    # Java-related tools.
+    #
+    # As per the discussion in b/154357088, the input for this process
+    # is, properly, the core-for-system-modules.jar included starting in
+    # SDK 30. The steps taken to transform the Jar are discussed in
+    # b/63986449.
+    #
+    # The equivalent AGP implementation is located at
+    # https://android.googlesource.com/platform/tools/base/+/mirror-goog-studio-main/build-system/gradle-core/src/main/java/com/android/build/gradle/internal/dependency/JdkImageTransformDelegate.kt
+    def generate_android_image(self, state: 'ModuleState', sdk: int) -> T.List[CustomTarget]:
+        # core-for-system-modules.jar seem to be available since either SDK 30 or 31 (conflicting reports)
+        assert sdk >= 31
+
+        tools = self.get_java_tools(state, True)
+
+        imgtgt = f'android{sdk}_image'
+
+        work_dir = os.path.join(state.environment.private_dir, imgtgt)
+        os.makedirs(work_dir, exist_ok=True)
+        os.makedirs(os.path.join(work_dir, 'jmod'), exist_ok=True)
+
+        system_core_jar_path = os.path.join(self.android_home, 'platforms', f'android-{sdk}', 'core-for-system-modules.jar')
+
+        module_info_java = CustomTarget(
+            'module-info.java',
+            work_dir,
+            state.subproject,
+            state.environment,
+            [
+                *state.environment.get_build_command(), '--internal',
+                'android', 'modinfo-generate',
+                '@OUTPUT@', '@INPUT@', 'java.base'
+            ],
+            [system_core_jar_path],
+            ['module-info.java']
+        )
+
+        module_info_cls = CustomTarget(
+            'module-info.class',
+            work_dir,
+            state.subproject,
+            state.environment,
+            [*tools.javac.exelist, '--system=none', f'--patch-module=java.base={system_core_jar_path}', '-d', work_dir, '@INPUT@'],
+            [module_info_java],
+            ['module-info.class']
+        )
+
+        module_jar = CustomTarget(
+            'module.jar',
+            work_dir,
+            state.subproject,
+            state.environment,
+            [
+                *state.environment.get_build_command(), '--internal',
+                'android', 'zipmerge',
+                '@OUTPUT@', '@INPUT@'
+            ],
+            [system_core_jar_path, module_info_cls],
+            ['module.jar']
+        )
+
+        jlink_version = tools.linking.jlink.get_version().split('.')[0]
+
+        jmod = CustomTarget(
+            'java.base.jmod',
+            os.path.join(work_dir, 'jmod'),
+            state.subproject,
+            state.environment,
+            [
+                *state.environment.get_build_command(), '--internal',
+                'android', 'jmod', '@OUTPUT@',
+                tools.linking.jmod, 'create',
+                '--module-version', jlink_version,
+                # --target-platform android was replaced with
+                # LINUX-OTHER to be compatible with JDK 21+ b/294137077
+                '--target-platform', 'LINUX-OTHER',
+                '--class-path', '@INPUT@'
+            ],
+            [module_jar],
+            ['java.base.jmod']
+        )
+
+        jimg = CustomTarget(
+            'image',
+            work_dir,
+            state.subproject,
+            state.environment,
+            [
+                *state.environment.get_build_command(), '--internal',
+                'android', 'jlink', os.path.join(work_dir, 'image'), os.path.join(tools.java_home, 'lib', 'jrt-fs.jar'),
+                tools.linking.jlink,
+                '--module-path', os.path.join(work_dir, 'jmod'),
+                '--add-modules', 'java.base',
+                '--disable-plugin', 'system-modules'
+            ],
+            [jmod],
+            ['image.tgt']
+        )
+
+        self.android_images[sdk] = (os.path.join(work_dir, 'image'), jimg)
+        return [module_info_java, module_info_cls, module_jar, jmod, jimg]
+
+    @FeatureNew('android.generate_apk', '1.11.0')
+    @typed_pos_args(
+        'android.generate_apk',
+        (str, File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList),
+        varargs=APK_SOURCES_VARARGS
+    )
+    @typed_kwargs(
+        'android.generate_apk',
+        KwargInfo('app_id', (str, NoneType)),
+        KwargInfo('target_sdk', (int, NoneType)),
+        KwargInfo('min_sdk', (int, NoneType)),
+        KwargInfo('resources', ContainerTypeInfo(list, (str, File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)), listify=True, default=[]),
+        INSTALL_KW,
+        INSTALL_DIR_KW,
+        INSTALL_TAG_KW,
+    )
+    def generate_apk(self, state: 'ModuleState',
+                     args: T.Tuple[T.Union[str, File, 'GeneratedTypes'], 'ApkSourcesType'],
+                     kwargs: 'GenerateApk') -> ModuleReturnValue:
+        manifest_file, sources = args
+
+        if isinstance(manifest_file, str):
+            manifest_file = File.from_source_file(state.environment.source_dir, state.subdir, manifest_file)
+
+        tgts: T.List[build.Target] = []
+
+        app_id = kwargs['app_id']
+        manifest_src = manifest_file
+        if app_id is not None:
+            work_dir = os.path.join(state.subdir, f'{app_id}.p')
+            os.makedirs(os.path.join(state.environment.get_build_dir(), work_dir), exist_ok=True)
+
+            manifest_src = CustomTarget(
+                'AndroidManifest.xml',
+                work_dir,
+                state.subproject,
+                state.environment,
+                [
+                    *state.environment.get_build_command(), '--internal',
+                    'android', 'manifest-rewriter', '@INPUT@',
+                    '--output', '@OUTPUT@',
+                    '--appid', app_id
+                ],
+                [manifest_file],
+                ['AndroidManifest.xml']
+            )
+            tgts.append(manifest_src)
+        else:
+            if not isinstance(manifest_file, File):
+                raise MesonException('app_id is required if manifest is not a file')
+            manifest = ET.parse(manifest_file.absolute_path(state.environment.source_dir, state.environment.build_dir))
+            mf_root = manifest.getroot()
+            if mf_root is None or mf_root.tag != 'manifest':
+                raise MesonException(f'Manifest {manifest_file} is not a valid android manifest')
+            app_id = mf_root.get('package')
+            if app_id is None:
+                raise MesonException('app_id is required if not specified in the manifest')
+
+            work_dir = os.path.join(state.subdir, f'{app_id}.p')
+            os.makedirs(os.path.join(state.environment.get_build_dir(), work_dir), exist_ok=True)
+
+        target_sdk = kwargs['target_sdk']
+        if target_sdk is None:
+            raise MesonException('TODO: pick latest version from $ANDROID_HOME/platforms/')
+        min_sdk = kwargs['min_sdk']
+        if min_sdk is None:
+            raise MesonException('TODO: determine min version from C compiler name')
+
+        javac_args: T.List[str] = []
+        javac_tgt_deps: T.List[CustomTarget] = []
+
+        if target_sdk >= 36:
+            # Starting with SDK 36, Android Studio defaults to Java 11,
+            # as newer JDKs have deprecated support for Java 8 source &
+            # target compatability. As such we'll need to pass java a
+            # 'system image' describing java.base, which we'll have to
+            # construct first.
+            # Should the Java 8 deprecation become an actual problem for
+            # us, I *belive* we could use Java 11 starting with SDK 30
+            # or 31, as those are this first SDKs shipping the resources
+            # needed to create the system image.
+            if target_sdk not in self.android_images:
+                tgts.extend(self.generate_android_image(state, target_sdk))
+            img, dep = self.android_images[target_sdk]
+            javac_args += ['-source', '11', '-target', '11', '--system', img]
+            javac_tgt_deps.append(dep)
+        else:
+            javac_args += ['-source', '8', '-target', '8']
+
+        tools = self.get_android_tools(state)
+
+        if kwargs['resources']:
+            resources = CustomTarget(
+                'resources.zip',
+                work_dir,
+                state.subproject,
+                state.environment,
+                [
+                    tools.aapt2, 'compile',
+                    '-o', '@OUTPUT@',
+                    '@INPUT@'
+                ],
+                self.interpreter.source_strings_to_files(kwargs['resources']),
+                ['resources.zip']
+            )
+            tgts.append(resources)
+        else:
+            resources = None
+
+        android_platform_jar = os.path.join(self.android_home, 'platforms', f'android-{target_sdk}', 'android.jar')
+
+        container_apk, container_res = container_tgt = CustomTarget(
+            'container.apk',
+            work_dir,
+            state.subproject,
+            state.environment,
+            T.cast(T.List[T.Union[str, 'Program']], [
+                tools.aapt2, 'link',
+                '-o', '@OUTPUT0@',
+                '--min-sdk-version', str(min_sdk),
+                '--target-sdk-version', str(target_sdk),
+                '--manifest', '@INPUT0@',
+                '--java', '@OUTDIR@/java',
+                '-I', '@INPUT1@'
+            ] + ['@INPUT2@'] if resources is not None else []),
+            [manifest_src, android_platform_jar] + [resources] if resources is not None else [],
+            ['container.apk', os.sep.join(['java', *app_id.split('.'), 'R.java'])]
+        )
+        tgts.append(container_tgt)
+
+        java_sources = [container_res]
+        java_jars = []
+
+        for source in sources:
+            if isinstance(source, Jar):
+                java_jars.append(source)
+            else:
+                java_sources.append(source)
+
+        app_java_tgt = Jar(
+            app_id,
+            # using work_dir here is problematic, as it is used by the backend to determine the -sourcepath argument.
+            # Specifically, with this being work dir, the backend adds <srcroot>/<subdir>/<app_id>.p/ (which doesn't
+            # exist and doesn't add <srcroot>/<subdir> (which should be added).
+            work_dir,
+            state.subproject,
+            MachineChoice.HOST,
+            self.interpreter.source_strings_to_files(java_sources),
+            None, [],
+            state.environment,
+            self.interpreter.compilers[MachineChoice.HOST],
+            {
+                'language_args': {
+                    # setting the classpath here sucks, I'd rather extend mesons link_with: jar support to external jars
+                    'java': javac_args + ['-cp', ':'.join([android_platform_jar])],
+                },
+                # TODO: link_depends does not work for java
+                'link_depends': javac_tgt_deps
+            }
+        )
+        tgts.append(app_java_tgt)
+        java_jars.append(app_java_tgt)
+
+        dexed = CustomTarget(
+            'classes.dex',
+            work_dir,
+            state.subproject,
+            state.environment,
+            [
+                tools.d8,
+                '--classpath', ':'.join([android_platform_jar]),
+                '--output', '@OUTDIR@',
+                '@INPUT@'
+            ],
+            java_jars,
+            ['classes.dex']
+        )
+        tgts.append(dexed)
+
+        merged = CustomTarget(
+            'merged.apk',
+            work_dir,
+            state.subproject,
+            state.environment,
+            [
+                *state.environment.get_build_command(), '--internal',
+                'android', 'zipmerge',
+                '@OUTPUT@', '@INPUT@'
+            ],
+            [container_apk, dexed],
+            ['merged.apk']
+        )
+        tgts.append(merged)
+
+        signing_data: T.Optional[T.Tuple[str, str, str, str, str]] = None
+        # TODO: potentially have keystore, alias, keystore_password & key_password kwargs?
+        #       It's the way gradle does it, but in our case that would
+        #       imply leaking the keystore password in the ninja file.
+        android_user_home = os.getenv('ANDROID_USER_HOME') or os.path.expanduser('~/.android/')
+        debug_keystore_loc = os.path.join(android_user_home, 'debug.keystore')
+        if os.path.isfile(os.path.expanduser(debug_keystore_loc)):
+            signing_data = (debug_keystore_loc, 'AndroidDebugKey', 'android', 'android', 'debugsigned')
+        else:
+            mlog.warning('Unable to find debug keystore, the generated apk will not be signed')
+
+        final_tgt_kwargs: T.Dict[str, T.Any] = {
+            'build_by_default': True,
+            'install': kwargs['install'],
+            'install_dir': kwargs['install_dir'],
+            'install_tag': kwargs['install_tag']
+        }
+
+        final = aligned = CustomTarget(
+            f'{app_id}-unsigned.apk',
+            work_dir if signing_data is not None else state.subdir,
+            state.subproject,
+            state.environment,
+            [
+                tools.zipalign,
+                '-P', '16', '4',
+                '@INPUT@',
+                '-f', '@OUTPUT@'
+            ],
+            [merged],
+            [f'{app_id}-unsigned.apk'],
+            **({} if signing_data is not None else final_tgt_kwargs)
+        )
+        tgts.append(aligned)
+
+        if signing_data is not None:
+            ks, alias, ks_pw, key_pw, suffix = signing_data
+            final = signed = CustomTarget(
+                f'{app_id}-{suffix}.apk',
+                state.subdir,
+                state.subproject,
+                state.environment,
+                [
+                    tools.apksigner, 'sign',
+                    '--ks', '@INPUT1@',
+                    '--ks-key-alias', alias,
+                    '--ks-pass', f'pass:{ks_pw}',
+                    '--key-pass', f'pass:{key_pw}',
+                    '--in', '@INPUT0@',
+                    '--out', '@OUTPUT@'
+                ],
+                [aligned, File.from_absolute_file(debug_keystore_loc)],
+                [f'{app_id}-{suffix}.apk'],
+                **final_tgt_kwargs
+            )
+            tgts.append(signed)
+
+        return ModuleReturnValue(final, tgts)
+
+def initialize(interpreter: 'Interpreter') -> AndroidModule:
+    return AndroidModule(interpreter)
diff --git a/mesonbuild/scripts/android.py b/mesonbuild/scripts/android.py
new file mode 100644
index 000000000000..c58f1b375963
--- /dev/null
+++ b/mesonbuild/scripts/android.py
@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026  Florian Leander Singer <sp1rit@disroot.org>
+
+import typing as T
+import argparse
+import os
+import re
+import shutil
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from zipfile import ZipFile, BadZipFile
+
+def modinfo_generate(args: T.List[str]) -> int:
+    if len(args) != 3:
+        print('Usage: modinfo-generate <OUTPUT> <path/to/jar.jar> <module name>')
+        return 2
+
+    with ZipFile(args[1]) as system_core_jar:
+        pat = re.compile(r"(.*)/[^/]*.class")
+        packages = sorted({m.group(1).replace('/', '.') for file in system_core_jar.namelist() if (m := pat.search(file))})
+
+    with open(args[0], 'w', encoding='utf-8') as f:
+        f.write(f'module {args[2]} {{')
+        for package in packages:
+            f.write(f'\texports {package};\n')
+        f.write('}')
+
+    return 0
+
+zipmerge_parser = argparse.ArgumentParser()
+zipmerge_parser.add_argument('output')
+zipmerge_parser.add_argument('input', nargs='*')
+# Ignore manifest.mf as it contains unnecessary data causing build cache misses, b/234820480.
+zipmerge_parser.add_argument('--ignore-manifest', action='store_true')
+def zipmerge(args: T.List[str]) -> int:
+    parsed = zipmerge_parser.parse_args(args)
+    with ZipFile(parsed.output, mode='w') as outzip:
+        for infile in parsed.input:
+            try:
+                with ZipFile(infile) as inzip:
+                    for member in inzip.infolist():
+                        if parsed.ignore_manifest and member.filename.casefold() == 'meta-inf/manifest.mf':
+                            continue
+                        if member.is_dir():
+                            outzip.mkdir(member)
+                        else:
+                            outzip.writestr(member, inzip.read(member.filename))
+            except BadZipFile:
+                # Assume infile is plain file to be added
+                outzip.write(infile, os.path.basename(infile))
+    return 0
+
+def jmod(args: T.List[str]) -> int:
+    if len(args) < 2:
+        print('Usage: jmod <OUTPUT> </path/to/jmod> [ARGS ...]')
+        return 2
+
+    try:
+        os.remove(args[0])
+    except OSError:
+        pass
+
+    subprocess.check_call(args[1:] + [args[0]])
+    return 0
+
+# jlink is a bit annoying. Not only does it produce a directory (cause
+# the JVM system image is a directory)
+# To work arround these issues, we generate a "faux" output right next
+# to the directory for ninja to work with.
+def jlink(args: T.List[str]) -> int:
+    if len(args) < 3:
+        print('Usage: jlink <OUTPUT> </path/to/jrt-fs.jar> </path/to/jlink> [ARGS ...]')
+        return 2
+
+    output = args[0]
+    try:
+        shutil.rmtree(output)
+    except FileNotFoundError:
+        pass
+
+    subprocess.check_call(args[2:] + ['--output', output])
+    with open(f'{os.path.normpath(output)}.tgt', 'wb'):
+        pass
+
+    os.makedirs(os.path.join(output, 'lib'), exist_ok=True)
+    return zipmerge([
+        os.path.join(output, 'lib', 'jrt-fs.jar'),
+        '--ignore-manifest', args[1]
+    ])
+
+manifest_rewriter_parser = argparse.ArgumentParser()
+manifest_rewriter_parser.add_argument('manifest')
+manifest_rewriter_parser.add_argument('--output', action='store', required=True)
+manifest_rewriter_parser.add_argument('--appid', action='store')
+def manifest_rewriter(args: T.List[str]) -> int:
+    parsed = manifest_rewriter_parser.parse_args(args)
+    manifest = ET.parse(parsed.manifest)
+    mf_root = manifest.getroot()
+    if mf_root is None or mf_root.tag != 'manifest':
+        print(f'Manifest {parsed.manifest} is not a valid android manifest', file=sys.stderr)
+        return 1
+    if parsed.appid is not None:
+        mf_root.set('package', parsed.appid)
+    manifest.write(parsed.output, encoding="utf-8", xml_declaration=True)
+    return 0
+
+SUBCOMMANDS: T.Dict[str, T.Callable[[T.List[str]], int]] = {
+    'modinfo-generate': modinfo_generate,
+    'zipmerge': zipmerge,
+    'jmod': jmod,
+    'jlink': jlink,
+
+    'manifest-rewriter': manifest_rewriter
+}
+
+def run(args: T.List[str]) -> int:
+    if not args or args[0] not in SUBCOMMANDS:
+        print('Unknown subcommand')
+        return 2
+    return SUBCOMMANDS[args[0]](args[1:])
diff --git a/run_mypy.py b/run_mypy.py
index 6c0ddaaa4752..4580b07714b2 100755
--- a/run_mypy.py
+++ b/run_mypy.py
@@ -54,6 +54,7 @@
     'mesonbuild/mlog.py',
     'mesonbuild/msubprojects.py',
     'mesonbuild/modules/__init__.py',
+    'mesonbuild/modules/android.py',
     'mesonbuild/modules/cmake.py',
     'mesonbuild/modules/codegen.py',
     'mesonbuild/modules/cuda.py',
diff --git a/test cases/android/2 apk/AndroidManifest.xml b/test cases/android/2 apk/AndroidManifest.xml
new file mode 100644
index 000000000000..8d51c189128d
--- /dev/null
+++ b/test cases/android/2 apk/AndroidManifest.xml	
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:label="@string/app_name"
+        android:icon="@mipmap/ic_launcher"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:theme="@style/Theme.AppTheme">
+        <activity
+            android:name=".MesonActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
diff --git a/test cases/android/2 apk/com/mesonbuild/android/apk/MesonActivity.java b/test cases/android/2 apk/com/mesonbuild/android/apk/MesonActivity.java
new file mode 100644
index 000000000000..4e3035c893ae
--- /dev/null
+++ b/test cases/android/2 apk/com/mesonbuild/android/apk/MesonActivity.java	
@@ -0,0 +1,16 @@
+package com.mesonbuild.android.apk;
+
+import android.app.Activity;
+import android.os.Build;
+import android.os.Bundle;
+
+public class MesonActivity extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (Build.VERSION.SDK_INT < 35)
+            getWindow().setDecorFitsSystemWindows(false);
+
+        setContentView(R.layout.meson_activity);
+    }
+}
diff --git a/test cases/android/2 apk/meson.build b/test cases/android/2 apk/meson.build
new file mode 100644
index 000000000000..0010d6a967b4
--- /dev/null
+++ b/test cases/android/2 apk/meson.build	
@@ -0,0 +1,20 @@
+project('android apk', 'java',
+  meson_version: '>= 1.11'
+)
+
+android = import('android')
+
+android.generate_apk('AndroidManifest.xml', 'com/mesonbuild/android/apk/MesonActivity.java',
+  app_id: 'com.mesonbuild.android.apk',
+  target_sdk: 36,
+  min_sdk: 31,
+  resources: [
+    'res/drawable/ic_meson.xml',
+    'res/drawable/img_meson.xml',
+    'res/layout/meson_activity.xml',
+    'res/mipmap-anydpi/ic_launcher_round.xml',
+    'res/mipmap-anydpi/ic_launcher.xml',
+    'res/values/strings.xml',
+    'res/values/themes.xml'
+  ]
+)
diff --git a/test cases/android/2 apk/res/drawable/ic_meson.xml b/test cases/android/2 apk/res/drawable/ic_meson.xml
new file mode 100644
index 000000000000..4fa10a7acbea
--- /dev/null
+++ b/test cases/android/2 apk/res/drawable/ic_meson.xml	
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+	android:width="108dp"
+	android:height="108dp"
+	android:viewportWidth="36"
+	android:viewportHeight="36"
+>
+	<path
+		android:fillColor="#39207c"
+		android:pathData="M 17.967447,8.521002 C 12.718701,11.484405 9.459874,17.036811 9.43,23.067847 c 5.491284,2.9939 11.939423,2.891789 16.9364,0.03152 6.24e-4,-0.01445 0.0014,-0.02902 0.0026,-0.04341 C 26.3627,17.057284 23.160293,11.517032 17.967465,8.521 Z m 2.825662,6.421282 c 0.778181,0.528807 0.662783,1.801968 0.537431,2.673726 -0.159504,0.960292 -1.080194,2.539029 -2.276341,3.569272 0.154728,0.221847 0.245213,0.495042 0.243911,0.786512 -0.741226,0.374671 -1.476729,-0.04802 -2.366259,-0.809766 -0.889527,-0.761753 -1.84892,-2.287919 -2.167303,-3.856593 -0.282398,0.0299 -0.571565,-0.0332 -0.819588,-0.189652 0.06478,-0.879603 0.99835,-1.402062 1.825724,-1.710481 0.827377,-0.308418 2.958883,-0.412812 4.461734,0.121439 0.117184,-0.246033 0.311298,-0.452882 0.560691,-0.58394 z"/>
+</vector>
diff --git a/test cases/android/2 apk/res/drawable/img_meson.xml b/test cases/android/2 apk/res/drawable/img_meson.xml
new file mode 100644
index 000000000000..ed486c49dc34
--- /dev/null
+++ b/test cases/android/2 apk/res/drawable/img_meson.xml	
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+	android:width="256dp"
+	android:height="256dp"
+	android:viewportWidth="24"
+	android:viewportHeight="24"
+>
+	<path
+		android:fillColor="#39207c"
+		android:pathData="M 12.067447,3.621002 C 6.8187007,6.5844046 3.559874,12.136811 3.53,18.167847 c 5.4912837,2.9939 11.939423,2.891789 16.9364,0.03152 6.24e-4,-0.01445 0.0014,-0.02902 0.0026,-0.04341 C 20.4627,12.157284 17.260293,6.6170324 12.067465,3.621 Z m 2.825662,6.421282 c 0.778181,0.528807 0.662783,1.801968 0.537431,2.673726 -0.159504,0.960292 -1.080194,2.539029 -2.276341,3.569272 0.154728,0.221847 0.245213,0.495042 0.243911,0.786512 -0.741226,0.374671 -1.476729,-0.04802 -2.366259,-0.809766 -0.889527,-0.761753 -1.8489204,-2.287919 -2.1673035,-3.856593 -0.2823971,0.0299 -0.571565,-0.0332 -0.8195876,-0.189652 0.064781,-0.879603 0.9983503,-1.402062 1.8257246,-1.710481 0.8273765,-0.308418 2.9588825,-0.412812 4.4617335,0.121439 0.117184,-0.246033 0.311298,-0.452882 0.560691,-0.58394 z"/>
+</vector>
diff --git a/test cases/android/2 apk/res/layout/meson_activity.xml b/test cases/android/2 apk/res/layout/meson_activity.xml
new file mode 100644
index 000000000000..56af671fbcb0
--- /dev/null
+++ b/test cases/android/2 apk/res/layout/meson_activity.xml	
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	xmlns:app="http://schemas.android.com/apk/res-auto"
+	xmlns:tools="http://schemas.android.com/tools"
+	android:layout_width="match_parent"
+	android:layout_height="match_parent"
+	android:orientation="vertical"
+	android:gravity="center">
+
+	<ImageView
+		android:id="@+id/imageView"
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:src="@drawable/img_meson" />
+
+	<TextView
+		android:layout_width="wrap_content"
+		android:layout_height="wrap_content"
+		android:text="@string/body_text"
+	/>
+</LinearLayout>
diff --git a/test cases/android/2 apk/res/mipmap-anydpi/ic_launcher.xml b/test cases/android/2 apk/res/mipmap-anydpi/ic_launcher.xml
new file mode 100644
index 000000000000..e8f19345c2c3
--- /dev/null
+++ b/test cases/android/2 apk/res/mipmap-anydpi/ic_launcher.xml	
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+	<background android:drawable="@android:color/white" />
+	<foreground android:drawable="@drawable/ic_meson" />
+	<monochrome android:drawable="@drawable/ic_meson" />
+</adaptive-icon>
diff --git a/test cases/android/2 apk/res/mipmap-anydpi/ic_launcher_round.xml b/test cases/android/2 apk/res/mipmap-anydpi/ic_launcher_round.xml
new file mode 100644
index 000000000000..e8f19345c2c3
--- /dev/null
+++ b/test cases/android/2 apk/res/mipmap-anydpi/ic_launcher_round.xml	
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+	<background android:drawable="@android:color/white" />
+	<foreground android:drawable="@drawable/ic_meson" />
+	<monochrome android:drawable="@drawable/ic_meson" />
+</adaptive-icon>
diff --git a/test cases/android/2 apk/res/values/strings.xml b/test cases/android/2 apk/res/values/strings.xml
new file mode 100644
index 000000000000..2ef2405ce719
--- /dev/null
+++ b/test cases/android/2 apk/res/values/strings.xml	
@@ -0,0 +1,4 @@
+<resources>
+	<string name="app_name">Meson Apk</string>
+	<string name="body_text">This is an Application built entirely using Meson, without AGP.</string>
+</resources>
diff --git a/test cases/android/2 apk/res/values/themes.xml b/test cases/android/2 apk/res/values/themes.xml
new file mode 100644
index 000000000000..e5ebbb647bef
--- /dev/null
+++ b/test cases/android/2 apk/res/values/themes.xml	
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<style name="Theme.AppTheme" parent="android:style/Theme.Material.Light.NoActionBar">
+		<item name="android:windowLightStatusBar">true</item>
+	</style>
+</resources>