const adapter = await navigator.gpu.requestAdapter();

    if(!adapter){
      throw Error("Couldn't request WebGPU Adapter")
    }
    const device = await adapter?.requestDevice();

    if(!device){
      throw Error("Couldn't request WebGPU logical device")
    }

    return new Promise(resolve => {
      const sizeArray = new Int32Array([width, height]);
      const gpuWidthHeightBuffer = device?.createBuffer({
        mappedAtCreation: true,
        size: sizeArray.byteLength,
        usage: GPUBufferUsage.STORAGE,
      });

      new Int32Array((gpuWidthHeightBuffer as GPUBuffer).getMappedRange()).set(
        sizeArray
      );
      gpuWidthHeightBuffer?.unmap();

      const gpuInputBuffer = device?.createBuffer({
        mappedAtCreation: true,
        size: array.byteLength,
        usage: GPUBufferUsage.STORAGE,
      });

      // "possibly null" -> ? setzen
      // "possibly undefined" -> as ...
      new Uint8Array((gpuInputBuffer as GPUBuffer).getMappedRange()).set(array);
      gpuInputBuffer?.unmap();

      const gpuResultBuffer = device?.createBuffer({
        size: array.byteLength,
        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
      });

      const gpuReadBuffer = device?.createBuffer({
        size: array.byteLength,
        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
      });

      const bindGroupLayout = device?.createBindGroupLayout({
        entries: [
          {
            binding: 0,
            visibility: GPUShaderStage.COMPUTE,
            buffer: {
              type: "read-only-storage"
            }
          } as GPUBindGroupLayoutEntry,
          {
            binding: 1,
            visibility: GPUShaderStage.COMPUTE,
            buffer: {
              type: "read-only-storage"
            }
          } as GPUBindGroupLayoutEntry,
          {
            binding: 2,
            visibility: GPUShaderStage.COMPUTE,
            buffer: {
              type: "storage"
            },
          } as GPUBindGroupLayoutEntry,
        ]
      });


      const bindGroup = device?.createBindGroup({
        layout: bindGroupLayout as GPUBindGroupLayout,
        entries: [
          {
            binding: 0,
            resource: {
              buffer: gpuWidthHeightBuffer as GPUBuffer
            }
          },
          {
            binding: 1,
            resource: {
              buffer: gpuInputBuffer as GPUBuffer
            }
          },
          {
            binding: 2,
            resource: {
              buffer: gpuResultBuffer as GPUBuffer
            }
          }
        ]
      });

      const module = device?.createShaderModule({code: shader })

      const computePipeline = device?.createComputePipeline({
        layout: device.createPipelineLayout({
          bindGroupLayouts: [bindGroupLayout] as Iterable<GPUBindGroupLayout>
        }),
        compute: {
          module,
          entryPoint: "main"
        }
      });

      const commandEncoder = device?.createCommandEncoder();
      const passEncoder = commandEncoder?.beginComputePass();
      passEncoder?.setPipeline(computePipeline as GPUComputePipeline);
      passEncoder?.setBindGroup(0, bindGroup as GPUBindGroup);
      passEncoder?.dispatchWorkgroups(width, height);
      passEncoder?.end();

      commandEncoder?.copyBufferToBuffer(
        gpuResultBuffer as GPUBuffer,
        0,
        gpuReadBuffer as GPUBuffer,
        0,
        array.byteLength
      );
      device?.queue.submit([commandEncoder?.finish() as GPUCommandBuffer]);

      gpuReadBuffer?.mapAsync(GPUMapMode.READ).then(() => {
        resolve(new Uint8Array(gpuReadBuffer.getMappedRange()));
      });
    });
  }