diff --git a/generator/dawn_json_generator.py b/generator/dawn_json_generator.py
index 484d01d..90bf762 100644
--- a/generator/dawn_json_generator.py
+++ b/generator/dawn_json_generator.py
@@ -795,6 +795,7 @@
 def compute_kotlin_params(loaded_json, kotlin_json):
     params_kotlin = parse_json(loaded_json, enabled_tags=['art'])
     params_kotlin['kotlin_package'] = kotlin_json['kotlin_package']
+    params_kotlin['to_jni_type'] = kotlin_json['to_jni_type']
     kt_file_path = params_kotlin['kotlin_package'].replace('.', '/')
 
     # The 'length' members are removed as Kotlin can infer that from the container.
@@ -1502,6 +1503,15 @@
                 FileRender('art/api_kotlin_functions.kt',
                            'java/' + kt_file_path + '/Functions.kt',
                            [RENDER_PARAMS_BASE, params_kotlin]))
+            renders.append(
+                FileRender('art/structures.h', 'cpp/structures.h',
+                           [RENDER_PARAMS_BASE, params_kotlin]))
+            renders.append(
+                FileRender('art/structures.cpp', 'cpp/structures.cpp',
+                           [RENDER_PARAMS_BASE, params_kotlin]))
+            renders.append(
+                FileRender('art/methods.cpp', 'cpp/methods.cpp',
+                           [RENDER_PARAMS_BASE, params_kotlin]))
 
             for enum in (params_kotlin['by_category']['bitmask'] +
                          params_kotlin['by_category']['enum']):
diff --git a/generator/templates/art/methods.cpp b/generator/templates/art/methods.cpp
new file mode 100644
index 0000000..09dd9ed
--- /dev/null
+++ b/generator/templates/art/methods.cpp
@@ -0,0 +1,291 @@
+//* Copyright 2024 The Dawn & Tint Authors
+//*
+//* Redistribution and use in source and binary forms, with or without
+//* modification, are permitted provided that the following conditions are met:
+//*
+//* 1. Redistributions of source code must retain the above copyright notice, this
+//*    list of conditions and the following disclaimer.
+//*
+//* 2. Redistributions in binary form must reproduce the above copyright notice,
+//*    this list of conditions and the following disclaimer in the documentation
+//*    and/or other materials provided with the distribution.
+//*
+//* 3. Neither the name of the copyright holder nor the names of its
+//*    contributors may be used to endorse or promote products derived from
+//*    this software without specific prior written permission.
+//*
+//* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+//* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+//* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+//* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+//* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+//* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+//* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+//* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+//* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include <jni.h>
+#include "dawn/webgpu.h"
+#include "structures.h"
+
+// Converts every method call from the Kotlin-hosted version to the native version, performing
+// the necessary JNI calls to fetch data, and converting the data to the correct form.
+
+#define DEFAULT __attribute__((visibility("default")))
+
+namespace dawn::kotlin_api {
+
+struct UserData {
+    JNIEnv *env;
+    jobject callback;
+};
+
+{% macro render_method(method, object) %}
+    //*  A JNI-external method is built with the JNI signature expected to match the host Kotlin.
+    DEFAULT extern "C"
+    {% if method.return_type.category == 'structure' %}
+        {{ unreachable_code() }}   //*  Currently returning structures is not supported.
+    {% elif method.return_type.category in ['bitmask', 'enum'] -%}
+        jint
+    {%- elif method.return_type.category == 'object' -%}
+        jobject
+    {%- else -%}
+        {{ to_jni_type[method.return_type.name.get()] }}
+    {%- endif %}
+    {{ ' ' }}
+    Java_{{ kotlin_package.replace('.', '_') }}_
+            {{- object.name.CamelCase() if object else 'FunctionsKt' -}}
+            _{{ method.name.camelCase() }}(JNIEnv *env
+                    {{ ', jobject obj' if object else ', jclass clazz' -}}
+
+    {% set input_args = [] %}
+    //* Filter the list of method arguments. We ignore userdata and length arguments which are not
+    //* present in the Kotlin host method.
+    {% for arg in method.arguments if arg.name.get() != 'userdata'
+            and not method.arguments | selectattr('length', 'equalto', arg) | first %}
+        {% do input_args.append(arg) %}
+    {% endfor %}
+
+    //* Make the signature for each argument in turn.
+    {% for arg in input_args %},
+        {%- if arg.length == 'strlen' -%}
+            jstring
+        {%- elif arg.length and arg.constant_length != 1 %}
+            {%- if arg.type.category in [
+                    'bitmask', 'enum', 'function pointer', 'object', 'structure'] -%}
+                jobjectArray
+            {%- elif arg.type.name.get() == 'void' -%}
+                jobject
+            {%- elif arg.type.name.get() == 'uint32_t' -%}
+                jintArray
+            {%- else %}
+                //* Currently returning structures in callbacks is not supported.
+                {{ unreachable_code() }}
+            {% endif %}
+        {%- elif arg.type.category in ['function pointer', 'object', 'structure'] -%}
+            jobject
+        {%- elif arg.type.category in ['bitmask', 'enum'] -%}
+            jint
+        {%- elif arg.type.name.get() in ['float',  'int32_t', 'uint32_t', 'uint64_t', 'size_t'] -%}
+            {{ to_jni_type[arg.type.name.get()] }}
+        {%- else %}
+            {{ unreachable_code() }}
+        {% endif %}
+        {{ ' ' }}_{{ as_varName(arg.name) }}
+    {% endfor %}) {
+
+    //*  A variable is declared for each parameter of the native method.
+    {% for arg in method.arguments %}
+        {{ as_annotated_cType(arg) }};
+    {% endfor %}
+
+    //* Each parameter is converted from the JNI parameter to the expected form of the native
+    //* parameter.
+    {% for arg in input_args %}
+        {% if arg.length == 'strlen' %}
+            if (_{{ as_varName(arg.name) }}) {  //* Don't convert null strings.
+                {{ as_varName(arg.name) }} = env->GetStringUTFChars(_{{ as_varName(arg.name) }}, 0);
+            } else {
+                {{ as_varName(arg.name) }} = nullptr;
+            }
+        {% elif arg.constant_length == 1 %}
+            //*  Optional structure.
+            {% if arg.type.category == 'structure' %}
+                if (_{{ as_varName(arg.name) }}) {
+                    //* TODO(b/330293719): free associated resources.
+                    auto convertedMember = new {{ as_cType(arg.type.name) }}();
+                    Convert(env, _{{ as_varName(arg.name) }}, convertedMember);
+                    {{ as_varName(arg.name) }} = convertedMember;
+                } else {
+                    {{ as_varName(arg.name) }} = nullptr;
+                }
+            {% else %}
+                {{ unreachable_code() }}
+            {% endif %}
+        {% elif arg.length %}
+            //*  Container types.
+            {% if arg.type.name.get() == 'uint32_t' %}
+                //* TODO(b/330293719): free associated resources.
+                {{ as_varName(arg.name) }} =
+                        reinterpret_cast<{{ as_cType(arg.type.name) }}*>(
+                               env->GetIntArrayElements(_{{ as_varName(arg.name) }}, 0));
+               {{ arg.length.name.camelCase() }} =
+                       env->GetArrayLength(_{{ as_varName(arg.name) }});
+            {% elif arg.type.name.get() == 'void' %}
+                {{ as_varName(arg.name) }} =
+                        env->GetDirectBufferAddress(_{{ as_varName(arg.name) }});
+                {{ arg.length.name.camelCase() }} =
+                        env->GetDirectBufferCapacity(_{{ as_varName(arg.name) }});
+            {% else %} {
+                size_t length = env->GetArrayLength(_{{ as_varName(arg.name) }});
+                //* TODO(b/330293719): free associated resources.
+                auto out = new {{ as_cType(arg.type.name) }}[length]();
+                {% if arg.type.category in ['bitmask', 'enum'] %} {
+                    jclass memberClass = env->FindClass("{{ jni_name(arg.type) }}");
+                    jmethodID getValue = env->GetMethodID(memberClass, "getValue", "()I");
+                    for (int idx = 0; idx != length; idx++) {
+                        jobject element =
+                                env->GetObjectArrayElement(_{{ as_varName(arg.name) }}, idx);
+                        out[idx] = static_cast<{{ as_cType(arg.type.name) }}>(
+                                env->CallIntMethod(element, getValue));
+                    }
+                }
+                {% elif arg.type.category == 'object' %} {
+                    jclass memberClass = env->FindClass("{{ jni_name(arg.type) }}");
+                    jmethodID getHandle = env->GetMethodID(memberClass, "getHandle", "()J");
+                    for (int idx = 0; idx != length; idx++) {
+                        jobject element =
+                                env->GetObjectArrayElement(_{{ as_varName(arg.name) }}, idx);
+                        out[idx] = reinterpret_cast<{{ as_cType(arg.type.name) }}>(
+                                env->CallLongMethod(element, getHandle));
+                    }
+                }
+                {% else %}
+                    {{ unreachable_code() }}
+                {% endif %}
+                {{ as_varName(arg.name) }} = out;
+                {{ arg.length.name.camelCase() }} = length;
+            }
+            {% endif %}
+
+        //*  Single value types.
+        {% elif arg.type.category == 'object' %}
+            if (_{{ as_varName(arg.name) }}) {
+                jclass memberClass = env->FindClass("{{ jni_name(arg.type) }}");
+                jmethodID getHandle = env->GetMethodID(memberClass, "getHandle", "()J");
+                {{ as_varName(arg.name) }} =
+                        reinterpret_cast<{{ as_cType(arg.type.name) }}>(
+                                env->CallLongMethod(_{{ as_varName(arg.name) }}, getHandle));
+            } else {
+                {{ as_varName(arg.name) }} = nullptr;
+            }
+        {% elif arg.type.name.get() in ['int32_t', 'size_t', 'uint32_t', 'uint64_t']
+                or arg.type.category in ['bitmask', 'enum'] %}
+            {{ as_varName(arg.name) }} =
+                    static_cast<{{ as_cType(arg.type.name) }}>(_{{ as_varName(arg.name) }});
+        {% elif arg.type.name.get() in ['float', 'int'] %}
+            {{ as_varName(arg.name) }} = _{{ as_varName(arg.name) }};
+
+        {% elif arg.type.category == 'function pointer' %} {
+            //* Function pointers themselves require each argument converting.
+            //* A custom native callback is generated to wrap the Kotlin callback.
+            {{ as_varName(arg.name) }} = [](
+                {%- for callbackArg in arg.type.arguments %}
+                    {{ as_annotated_cType(callbackArg) }}{{ ',' if not loop.last }}
+                {%- endfor %}) {
+                UserData* userData1 = static_cast<UserData *>(userdata);
+                JNIEnv *env = userData1->env;
+                if (env->ExceptionCheck()) {
+                    return;
+                }
+
+                //* Get the client (Kotlin) callback so we can call it.
+                jmethodID callbackMethod = env->GetMethodID(
+                        env->FindClass("{{ jni_name(arg.type) }}"), "callback", "(
+                    {%- for callbackArg in arg.type.arguments if
+                            callbackArg.name.get() != 'userdata'-%}
+                        {%- if callbackArg.type.category in ['bitmask', 'enum'] -%}
+                            I
+                        {%- elif callbackArg.type.category in ['object', 'structure'] -%}
+                            L{{ jni_name(callbackArg.type) }};
+                        {%- elif callbackArg.type.name.get() == 'char' -%}
+                            Ljava/lang/String;
+                        {%- else -%}
+                            {{ unreachable_code() }}
+                        {%- endif -%}
+                    {%- endfor %})V");
+
+                //* Call the callback with all converted parameters.
+                env->CallVoidMethod(userData1->callback, callbackMethod
+                {%- for callbackArg in arg.type.arguments if callbackArg.name.get() != 'userdata' %}
+                    ,
+                    {%- if callbackArg.type.category == 'object' %}
+                        env->NewObject(env->FindClass("{{ jni_name(callbackArg.type) }}"),
+                                env->GetMethodID(env->FindClass("{{ jni_name(callbackArg.type) }}"),
+                                        "<init>", "(J)V"),
+                                reinterpret_cast<jlong>({{ callbackArg.name.camelCase() }}))
+                    {%- elif callbackArg.type.category in ['bitmask', 'enum'] %}
+                        static_cast<jint>({{ callbackArg.name.camelCase() }})
+                    {%- elif callbackArg.type.category == 'structure' %}
+                        {{ unreachable_code () }}  //* We don't yet handle structures in callbacks.
+                    {%- elif callbackArg.type.name.get() == 'char' %}
+                        env->NewStringUTF({{ callbackArg.name.camelCase() }})
+                    {%- else %}
+                        {{ callbackArg.name.camelCase() }}
+                    {%- endif %}
+                {%- endfor %});
+            };
+            //* TODO(b/330293719): free associated resources.
+            userdata = new UserData(
+                    {.env = env, .callback = env->NewGlobalRef(_{{ as_varName(arg.name) }})});
+        }
+        {% else %}
+            {{ unreachable_code() }}
+        {% endif %}
+    {% endfor %}
+
+    {% if object %}
+        jclass memberClass = env->FindClass("{{ jni_name(object) }}");
+        jmethodID getHandle = env->GetMethodID(memberClass, "getHandle", "()J");
+        auto handle =
+                reinterpret_cast<{{ as_cType(object.name) }}>(env->CallLongMethod(obj, getHandle));
+    {% endif %}
+
+    //* Actually invoke the native version of the method.
+    {{ 'auto result =' if method.return_type.name.get() != 'void' }}
+    {% if object %}
+        wgpu{{ object.name.CamelCase() }}{{ method.name.CamelCase() }}(handle
+    {% else %}
+        wgpu{{ method.name.CamelCase() }}(
+    {% endif %}
+        {% for arg in method.arguments -%}
+            {{- ',' if object or not loop.first }}{{ as_varName(arg.name) -}}
+        {% endfor %}
+    );
+    if (env->ExceptionCheck()) {  //* Early out if client (Kotlin) callback threw an exception.
+        return {{ '0' if method.return_type.name.get() != 'void' }};
+    }
+
+    //* We only handle objects and primitives to be returned.
+    {% if method.return_type.category == 'object' %}
+        jclass returnClass = env->FindClass("{{ jni_name(method.return_type) }}");
+        auto constructor = env->GetMethodID(returnClass, "<init>", "(J)V");
+        return env->NewObject(returnClass, constructor, reinterpret_cast<jlong>(result));
+    {% elif method.return_type.name.get() != 'void' %}
+        return result;  //* Primitives are implicitly converted by JNI.
+    {% endif %}
+}
+{% endmacro %}
+
+{% for obj in by_category['object'] %}
+    {% for method in obj.methods if include_method(method) %}
+        {{ render_method(method, obj) }}
+    {% endfor %}
+{% endfor %}
+
+//* Global functions don't have an associated class.
+{% for function in by_category['function'] if include_method(function) %}
+    {{ render_method(function, None) }}
+{% endfor %}
+
+}  // namespace dawn::kotlin_api
diff --git a/generator/templates/art/structures.cpp b/generator/templates/art/structures.cpp
new file mode 100644
index 0000000..af901f4
--- /dev/null
+++ b/generator/templates/art/structures.cpp
@@ -0,0 +1,193 @@
+//* Copyright 2024 The Dawn & Tint Authors
+//*
+//* Redistribution and use in source and binary forms, with or without
+//* modification, are permitted provided that the following conditions are met:
+//*
+//* 1. Redistributions of source code must retain the above copyright notice, this
+//*    list of conditions and the following disclaimer.
+//*
+//* 2. Redistributions in binary form must reproduce the above copyright notice,
+//*    this list of conditions and the following disclaimer in the documentation
+//*    and/or other materials provided with the distribution.
+//*
+//* 3. Neither the name of the copyright holder nor the names of its
+//*    contributors may be used to endorse or promote products derived from
+//*    this software without specific prior written permission.
+//*
+//* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+//* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+//* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+//* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+//* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+//* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+//* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+//* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+//* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include <jni.h>
+#include "dawn/webgpu.h"
+#include "structures.h"
+
+// Converts Kotlin objects representing Dawn structures into native structures that can be passed
+// into the native Dawn API.
+
+namespace dawn::kotlin_api {
+
+{% for structure in by_category['structure'] %}
+    void Convert(JNIEnv *env, jobject obj, {{ as_cType(structure.name) }}* converted) {
+        jclass clz = env->FindClass("{{ jni_name(structure) }}");
+
+        //* Convert each member in turn from corresponding members of the Kotlin object obtained via
+        //* JNI calls
+        {% for member in structure.members if include_structure_member(structure, member) %}
+            {% if member.length == 'strlen' %} {
+                jobject mObj = env->CallObjectMethod(obj,
+                        env->GetMethodID(clz, "get{{ member.name.CamelCase() }}",
+                                "()Ljava/lang/String;"));
+                if (mObj) {
+                    //* TODO(b/330293719): free associated resources.
+                    converted->{{ member.name.camelCase() }} =
+                            env->GetStringUTFChars(static_cast<jstring>(mObj), 0);
+                }
+            }
+            {% elif member.constant_length == 1 %} {
+                {% if member.type.category == 'structure' %}
+                    //* Convert optional structure if present.
+                    jobject mObj = env->CallObjectMethod(obj,
+                            env->GetMethodID(clz, "get{{ member.name.CamelCase() }}",
+                                    "()L{{ jni_name(member.type) }};"));
+                    if (mObj) {
+                        //* TODO(b/330293719): free associated resources.
+                        auto convertedMember = new {{ as_cType(member.type.name) }}();
+                        Convert(env, mObj, convertedMember);
+                        converted->{{ member.name.camelCase() }} = convertedMember;
+                    }
+                {% elif member.type.name.get() == 'void' %}
+                    converted->{{ member.name.camelCase() }} = reinterpret_cast<void*>(
+                            env->CallLongMethod(obj, env->GetMethodID(
+                                    clz, "get{{ member.name.CamelCase() }}", "()J")));
+                {% else %}
+                    {{ unreachable_code() }}
+                {% endif %}
+            }
+
+            {% elif member.length %}
+                {% if member.constant_length %}
+                    {{ unreachable_code() }}
+                {% endif %}
+                //* Convert container, including the length field.
+                {% if member.type.name.get() == 'uint32_t' %} {
+                    //* This container type is represented in Kotlin as a primitive array.
+                    jintArray array = static_cast<jintArray>(env->CallObjectMethod(obj,
+                            env->GetMethodID(clz, "get{{ member.name.CamelCase() }}", "()[I")));
+                    //* TODO(b/330293719): free associated resources.
+                    converted->{{ member.name.camelCase() }} =
+                            reinterpret_cast<{{ as_cType(member.type.name) }}*>(
+                                   env->GetIntArrayElements(array, 0));
+                    converted->{{ member.length.name.camelCase() }} = env->GetArrayLength(array);
+                }
+                {% else %} {
+                    //* These container types are represented in Kotlin as arrays of objects.
+                    jmethodID getMethod = env->GetMethodID(clz,
+                            "get{{ member.name.CamelCase() }}", "()[L{{ jni_name(member.type) }};");
+                    auto in = static_cast<jobjectArray>(env->CallObjectMethod(obj, getMethod));
+                    size_t length = env->GetArrayLength(in);
+                    //* TODO(b/330293719): free associated resources.
+                    auto out = new {{ as_cType(member.type.name) }}[length]();
+                    {% if member.type.category in ['bitmask', 'enum'] %} {
+                        jclass memberClass = env->FindClass("{{ jni_name(member.type) }}");
+                        jmethodID getValue = env->GetMethodID(memberClass, "getValue", "()I");
+                        for (int idx = 0; idx != length; idx++) {
+                            jobject element = env->GetObjectArrayElement(in, idx);
+                            out[idx] = static_cast<{{ as_cType(member.type.name) }}>(
+                                    env->CallIntMethod(element, getValue));
+                        }
+                    }
+                    {% elif member.type.category == 'object' %} {
+                        jclass memberClass = env->FindClass("{{ jni_name(member.type) }}");
+                        jmethodID getHandle = env->GetMethodID(memberClass, "getHandle", "()J");
+                        for (int idx = 0; idx != length; idx++) {
+                            jobject element = env->GetObjectArrayElement(in, idx);
+                            out[idx] = reinterpret_cast<{{ as_cType(member.type.name) }}>(
+                                    env->CallLongMethod(element, getHandle));
+                        }
+                    }
+                    {% elif member.type.category == 'structure' %}
+                        for (int idx = 0; idx != length; idx++) {
+                            Convert(env, env->GetObjectArrayElement(in, idx), out + idx);
+                        }
+                    {% else %}
+                        {{ unreachable_code() }}
+                    {% endif %}
+                    converted->{{ member.name.camelCase() }} = out;
+                    converted->{{ member.length.name.camelCase() }} = length;
+                }
+                {% endif %}
+
+            //* From here members are single values.
+            {% elif member.type.category == 'object' %} {
+                jobject mObj = env->CallObjectMethod(obj, env->GetMethodID(clz,
+                        "get{{ member.name.CamelCase() }}", "()L{{ jni_name(member.type) }};"));
+                if (mObj) {
+                    jclass memberClass = env->FindClass("{{ jni_name(member.type) }}");
+                    jmethodID getHandle = env->GetMethodID(memberClass, "getHandle", "()J");
+                    converted->{{ member.name.camelCase() }} =
+                            reinterpret_cast<{{ as_cType(member.type.name) }}>(
+                                    env->CallLongMethod(mObj, getHandle));
+                }
+            }
+            {% elif member.type.category == 'structure' %}
+                //* Mandatory structure.
+                Convert(env, env->CallObjectMethod(obj,
+                        env->GetMethodID(clz, "get{{ member.name.CamelCase() }}",
+                                "()L{{ jni_name(member.type) }};")),
+                                &converted->{{ member.name.camelCase() }});
+            {% elif member.type.name.get() == 'bool' %}
+                converted->{{ member.name.camelCase() }} = env->CallBooleanMethod(obj,
+                        env->GetMethodID(clz, "get{{ member.name.CamelCase() }}", "()Z"));
+            {% elif member.type.name.get() == 'uint16_t' %}
+                converted->{{ member.name.camelCase() }} =
+                        static_cast<{{ as_cType(member.type.name) }}>(env->CallShortMethod(obj,
+                                env->GetMethodID(clz, "get{{ member.name.CamelCase() }}", "()S")));
+            {% elif member.type.name.get() in ['int', 'int32_t', 'uint32_t']
+                    or member.type.category in ['bitmask', 'enum'] %}
+                converted->{{ member.name.camelCase() }} =
+                        static_cast<{{ as_cType(member.type.name) }}>(env->CallIntMethod(obj,
+                                env->GetMethodID(clz, "get{{ member.name.CamelCase() }}", "()I")));
+            {% elif member.type.name.get() == 'float' %}
+                converted->{{ member.name.camelCase() }} = env->CallFloatMethod(obj,
+                        env->GetMethodID(clz, "get{{ member.name.CamelCase() }}", "()F"));
+            {% elif member.type.name.get() in ['size_t', 'uint64_t'] %}
+                converted->{{ member.name.camelCase() }} =
+                        static_cast<{{ as_cType(member.type.name) }}>(env->CallLongMethod(obj,
+                                env->GetMethodID(clz, "get{{ member.name.CamelCase() }}", "()J")));
+            {% elif member.type.name.get() == 'double' %}
+                converted->{{ member.name.camelCase() }} = env->CallDoubleMethod(obj,
+                        env->GetMethodID(clz, "get{{ member.name.CamelCase() }}", "()D"));
+            {% else %}
+                {{ unreachable_code() }}
+            {% endif %}
+        {% endfor %}
+
+        //* Set up the chain type and links for child objects.
+        {% if structure.chained %}
+            converted->chain = {.sType = WGPUSType_{{ structure.name.CamelCase() }}};
+        {% endif %}
+
+        {% for child in chain_children[structure.name.get()] %} {
+            jobject child = env->CallObjectMethod(obj,
+                    env->GetMethodID(clz, "get{{ child.name.CamelCase() }}",
+                            "()L{{ jni_name(child) }};"));
+            if (child) {
+                //* TODO(b/330293719): free associated resources.
+                auto out = new {{ as_cType(child.name) }}();
+                Convert(env, child, out);
+                out->chain.next = converted->nextInChain;
+                converted->nextInChain = &out->chain;
+            }
+        }
+        {% endfor %}
+    }
+{% endfor %}
+
+}  // namespace dawn::kotlin_api
diff --git a/generator/templates/art/structures.h b/generator/templates/art/structures.h
new file mode 100644
index 0000000..c4552ca
--- /dev/null
+++ b/generator/templates/art/structures.h
@@ -0,0 +1,38 @@
+//* Copyright 2024 The Dawn & Tint Authors
+//*
+//* Redistribution and use in source and binary forms, with or without
+//* modification, are permitted provided that the following conditions are met:
+//*
+//* 1. Redistributions of source code must retain the above copyright notice, this
+//*    list of conditions and the following disclaimer.
+//*
+//* 2. Redistributions in binary form must reproduce the above copyright notice,
+//*    this list of conditions and the following disclaimer in the documentation
+//*    and/or other materials provided with the distribution.
+//*
+//* 3. Neither the name of the copyright holder nor the names of its
+//*    contributors may be used to endorse or promote products derived from
+//*    this software without specific prior written permission.
+//*
+//* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+//* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+//* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+//* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+//* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+//* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+//* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+//* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+//* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "dawn/webgpu.h"
+
+namespace dawn::kotlin_api {
+
+// Converts Kotlin objects representing Dawn structures into native structures that can be passed
+// into the native Dawn API.
+
+{% for structure in by_category['structure'] %}
+    void Convert(JNIEnv *env, jobject obj, {{ as_cType(structure.name) }}* converted);
+{% endfor %}
+
+}  // namespace dawn::kotlin_api
diff --git a/src/dawn/dawn_kotlin.json b/src/dawn/dawn_kotlin.json
index 80a8cde..1e9dfa0 100644
--- a/src/dawn/dawn_kotlin.json
+++ b/src/dawn/dawn_kotlin.json
@@ -30,5 +30,15 @@
 
     "_doc": "See docs/dawn/codegen.md",
 
-    "kotlin_package": "android.dawn"
+    "kotlin_package": "android.dawn",
+
+    "to_jni_type" : {
+        "bool": "jboolean",
+        "float": "jfloat",
+        "int32_t": "jint",
+        "size_t": "jlong",
+        "uint32_t": "jint",
+        "uint64_t": "jlong",
+        "void": "void"
+    }
 }
diff --git a/tools/android/BUILD.gn b/tools/android/BUILD.gn
index b5b9cd6..ccec004 100644
--- a/tools/android/BUILD.gn
+++ b/tools/android/BUILD.gn
@@ -30,6 +30,9 @@
 dawn_json_generator("kotlin_gen") {
   target = "kotlin"
   outputs = [
+    "cpp/methods.cpp",
+    "cpp/structures.cpp",
+    "cpp/structures.h",
     "java/android/dawn/Adapter.kt",
     "java/android/dawn/AdapterInfo.kt",
     "java/android/dawn/AdapterProperties.kt",
diff --git a/tools/android/webgpu/src/main/cpp/CMakeLists.txt b/tools/android/webgpu/src/main/cpp/CMakeLists.txt
index 4ec0b42..30d0216 100644
--- a/tools/android/webgpu/src/main/cpp/CMakeLists.txt
+++ b/tools/android/webgpu/src/main/cpp/CMakeLists.txt
@@ -43,7 +43,7 @@
 
 target_compile_definitions(webgpu_dawn PRIVATE WGPU_IMPLEMENTATION WGPU_SHARED_LIBRARY)
 
-add_library(native_dawn Util.cpp ${CMAKE_SOURCE_DIR}/gen/include/dawn/webgpu.h)
+add_library(native_dawn methods.cpp structures.cpp utils.cpp ${CMAKE_SOURCE_DIR}/gen/include/dawn/webgpu.h)
 
 # It is not clear why abs::raw_hash_set is not part of the bundled dependency tree naturally.
 bundle_libraries(webgpu_c_bundled webgpu_dawn native_dawn absl::raw_hash_set)