add untested implementation of text scale

add sprite flipping to example
Merge branch 'sprites'
2026-01-20 19:26:43 +01:00 · 2024-04-07 23:59:14 +02:00 · 2024-04-07 23:20:13 +02:00 · 2024-04-07 22:58:26 +02:00 · 2024-04-03 10:26:41 +02:00 · 2023-09-13 07:36:24 +02:00
44 changed files with 4402 additions and 2501 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -30,9 +30,9 @@ jobs:
      run: sudo apt-get install -y libxkbcommon-dev libasound2-dev
      if: matrix.os == 'ubuntu-latest'
    - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
    - name: Cache build dirs
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: |
          ~/.cargo/bin/
@@ -44,7 +44,7 @@ jobs:
    - name: Build
      run: cargo build --release --verbose
    - name: Upload artifact
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v3
      with:
        name: uw8-${{ matrix.build }}
        path: target/release/${{ matrix.exe }}
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -8,12 +8,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
      - name: build_and_deploy
-        uses: shalzz/zola-deploy-action@v0.14.1
+        uses: shalzz/zola-deploy-action@70a101a14bbdeed13e7a42a9ed06b35c9e9e826e
        env:
          # Target branch
          PAGES_BRANCH: gh-pages
          BUILD_DIR: site
          # Provide personal access token
-          TOKEN: $GITHUB_ACTOR:${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uw8"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -11,21 +11,21 @@ native = ["wasmtime", "uw8-window", "cpal", "rubato" ]
 browser = ["warp", "tokio", "tokio-stream", "webbrowser"]

 [dependencies]
-wasmtime = { version = "0.37.0", optional = true }
+wasmtime = { version = "19.0.1", optional = true }
 anyhow = "1"
-env_logger = "0.9"
+env_logger = "0.11.3"
 log = "0.4"
 uw8-window = { path = "uw8-window", optional = true }
-notify = "4"
-pico-args = "0.4"
+notify-debouncer-mini = { version = "0.4.1", default-features = false }
+pico-args = "0.5"
 curlywas = { git = "https://github.com/exoticorn/curlywas.git", rev = "0e7ea50" }
 wat = "1"
 uw8-tool = { path = "uw8-tool" }
 same-file = "1"
-warp = { version = "0.3.2", optional = true }
-tokio = { version = "1.17.0", features = ["sync", "rt"], optional = true }
-tokio-stream = { version = "0.1.8", features = ["sync"], optional = true }
-webbrowser = { version = "0.6.0", optional = true }
+warp = { version = "0.3.6", optional = true }
+tokio = { version = "1.37.0", features = ["sync", "rt"], optional = true }
+tokio-stream = { version = "0.1.15", features = ["sync"], optional = true }
+webbrowser = { version = "0.8.13", optional = true }
 ansi_term = "0.12.1"
-cpal = { version = "0.13.5", optional = true }
-rubato = { version = "0.11.0", optional = true }
+cpal = { version = "0.15.3", optional = true }
+rubato = { version = "0.15.0", optional = true }
--- a/README.md
+++ b/README.md
@@ -15,9 +15,9 @@ See [here](https://exoticorn.github.io/microw8/) for more information and docs.

 ## Downloads

-* [Linux](https://github.com/exoticorn/microw8/releases/download/v0.1.2/microw8-0.1.2-linux.tgz)
-* [MacOS](https://github.com/exoticorn/microw8/releases/download/v0.1.2/microw8-0.1.2-macos.tgz)
-* [Windows](https://github.com/exoticorn/microw8/releases/download/v0.1.2/microw8-0.1.2-windows.zip)
+* [Linux](https://github.com/exoticorn/microw8/releases/download/v0.2.2/microw8-0.2.2-linux.tgz)
+* [MacOS](https://github.com/exoticorn/microw8/releases/download/v0.2.2/microw8-0.2.2-macos.tgz)
+* [Windows](https://github.com/exoticorn/microw8/releases/download/v0.2.2/microw8-0.2.2-windows.zip)

 The download includes

--- a/examples/curlywas/sprites.cwa
+++ b/examples/curlywas/sprites.cwa
@@ -0,0 +1,21 @@
+include "../include/microw8-api.cwa"
+
+const SPRITE = 0x20000;
+
+export fn upd() {
+	cls(0);
+	let t = time() / 2_f;
+	let i: i32;
+	loop spriteLoop {
+		let inline x = sin(t * -1.3 + i as f32 * (3.141 / 30_f)) * 180_f + 160_f;
+		let inline y = sin(t * 1.7 + i as f32 * (3.141 / 40_f)) * 140_f + 120_f;
+		blitSprite(SPRITE, 16, x as i32, y as i32, (i & 3) * 0x200 + 0x100);
+		branch_if (i +:= 1) < 100: spriteLoop;
+	}
+}
+
+start fn start() {
+	printChar('OO');
+	circle(8_f, 8_f, 6_f, 75);
+	grabSprite(SPRITE, 16, 0, 0, 0);
+}
--- a/examples/include/microw8-api.cwa
+++ b/examples/include/microw8-api.cwa
@@ -30,10 +30,13 @@ import "env.printInt" fn printInt(i32);
 import "env.setTextColor" fn setTextColor(i32);
 import "env.setBackgroundColor" fn setBackgroundColor(i32);
 import "env.setCursorPosition" fn setCursorPosition(i32, i32);
-import "env.rectangle_outline" fn rectangle_outline(f32, f32, f32, f32, i32);
-import "env.circle_outline" fn circle_outline(f32, f32, f32, i32);
+import "env.rectangleOutline" fn rectangleOutline(f32, f32, f32, f32, i32);
+import "env.circleOutline" fn circleOutline(f32, f32, f32, i32);
 import "env.exp" fn exp(f32) -> f32;
 import "env.playNote" fn playNote(i32, i32);
+import "env.sndGes" fn sndGes(i32) -> f32;
+import "env.blitSprite" fn blitSprite(i32, i32, i32, i32, i32);
+import "env.grabSprite" fn grabSprite(i32, i32, i32, i32, i32);

 const TIME_MS = 0x40;
 const GAMEPAD = 0x44;
--- a/examples/include/microw8-api.wat
+++ b/examples/include/microw8-api.wat
@@ -30,10 +30,13 @@
 (import "env" "setTextColor" (func $setTextColor (param i32)))
 (import "env" "setBackgroundColor" (func $setBackgroundColor (param i32)))
 (import "env" "setCursorPosition" (func $setCursorPosition (param i32) (param i32)))
-(import "env" "rectangle_outline" (func $rectangle_outline (param f32) (param f32) (param f32) (param f32) (param i32)))
-(import "env" "circle_outline" (func $circle_outline (param f32) (param f32) (param f32) (param i32)))
+(import "env" "rectangleOutline" (func $rectangleOutline (param f32) (param f32) (param f32) (param f32) (param i32)))
+(import "env" "circleOutline" (func $circleOutline (param f32) (param f32) (param f32) (param i32)))
 (import "env" "exp" (func $exp (param f32) (result f32)))
 (import "env" "playNote" (func $playNote (param i32) (param i32)))
+(import "env" "sndGes" (func $sndGes (param i32) (result f32)))
+(import "env" "blitSprite" (func $blitSprite (param i32) (param i32) (param i32) (param i32) (param i32)))
+(import "env" "grabSprite" (func $grabSprite (param i32) (param i32) (param i32) (param i32) (param i32)))

 ;; to use defines, include this file with a preprocessor
 ;; like gpp (https://logological.org/gpp).
--- a/platform/Cargo.lock
+++ b/platform/Cargo.lock
@@ -110,9 +110,9 @@ dependencies = [

 [[package]]
 name = "crc32fast"
-version = "1.3.0"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "738c290dfaea84fc1ca15ad9c168d083b05a714e1efddd8edaab678dc28d2836"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
 dependencies = [
 "cfg-if",
 ]
@@ -151,32 +151,39 @@ dependencies = [
 "anyhow",
 "ariadne",
 "chumsky",
- "pico-args",
+ "pico-args 0.4.2",
 "wasm-encoder 0.10.0",
 "wasmparser 0.83.0",
 ]

 [[package]]
 name = "fallible_collections"
-version = "0.4.4"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52db5973b6a19247baf19b30f41c23a1bfffc2e9ce0a5db2f60e3cd5dc8895f7"
+checksum = "3f57ccc32870366ae684be48b32a1a2e196f98a42a9b4361fe77e13fd4a34755"
 dependencies = [
 "hashbrown",
 ]

 [[package]]
 name = "flate2"
-version = "1.0.22"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e6988e897c1c9c485f43b47a529cef42fde0547f9d8d41a7062518f1d8fc53f"
+checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
 dependencies = [
- "cfg-if",
 "crc32fast",
- "libc",
 "miniz_oxide",
 ]

+[[package]]
+name = "form_urlencoded"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+dependencies = [
+ "percent-encoding",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.3"
@@ -190,9 +197,9 @@ dependencies = [

 [[package]]
 name = "hashbrown"
-version = "0.11.2"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 dependencies = [
 "ahash 0.7.6",
 ]
@@ -212,6 +219,26 @@ version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"

+[[package]]
+name = "idna"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -225,17 +252,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"

 [[package]]
-name = "libc"
-version = "0.2.112"
+name = "lexopt"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
+checksum = "478ee9e62aaeaf5b140bd4138753d1f109765488581444218d3ddda43234f3e8"
+
+[[package]]
+name = "libc"
+version = "0.2.139"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"

 [[package]]
 name = "lodepng"
-version = "3.4.7"
+version = "3.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24844d5c0b922ddd52fb5bf0964a4c7f8e799a946ec01bb463771eb04fc1a323"
+checksum = "f0ad39f75bbaa4b10bb6f2316543632a8046a5bcf9c785488d79720b21f044f8"
 dependencies = [
+ "crc32fast",
 "fallible_collections",
 "flate2",
 "libc",
@@ -253,12 +287,11 @@ dependencies = [

 [[package]]
 name = "miniz_oxide"
-version = "0.4.4"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
+checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
 dependencies = [
 "adler",
- "autocfg",
 ]

 [[package]]
@@ -288,12 +321,24 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "percent-encoding"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+
 [[package]]
 name = "pico-args"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"

+[[package]]
+name = "pico-args"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
+
 [[package]]
 name = "platform"
 version = "0.1.0"
@@ -330,9 +375,9 @@ dependencies = [

 [[package]]
 name = "rgb"
-version = "0.8.31"
+version = "0.8.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a374af9a0e5fdcdd98c1c7b64f05004f9ea2555b6c75f211daa81268a3c50f1"
+checksum = "3603b7d71ca82644f79b5a06d1220e9a58ede60bd32255f698cb1af8838b8db3"
 dependencies = [
 "bytemuck",
 ]
@@ -357,6 +402,26 @@ dependencies = [
 "unicode-xid",
 ]

+[[package]]
+name = "thiserror"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "time"
 version = "0.1.43"
@@ -376,6 +441,36 @@ dependencies = [
 "crunchy",
 ]

+[[package]]
+name = "tinyvec"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54675592c1dbefd78cbd98db9bacd89886e1ca50692a0692baefffdeb92dd58"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
+dependencies = [
+ "tinyvec",
+]
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.9.0"
@@ -390,13 +485,24 @@ checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"

 [[package]]
 name = "upkr"
-version = "0.1.0"
-source = "git+https://github.com/exoticorn/upkr.git?rev=2e7983fc#2e7983fc650788d98da2eecef2d16f63e849e4a0"
+version = "0.2.1"
+source = "git+https://github.com/exoticorn/upkr.git?rev=080db40d0088bbee2bdf3c5c75288ac7853d6b7a#080db40d0088bbee2bdf3c5c75288ac7853d6b7a"
 dependencies = [
 "anyhow",
 "cdivsufsort",
- "pbr",
- "pico-args",
+ "lexopt",
+ "thiserror",
+]
+
+[[package]]
+name = "url"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
 ]

 [[package]]
@@ -405,11 +511,11 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "pbr",
- "pico-args",
+ "pico-args 0.5.0",
 "upkr",
 "walrus",
- "wasm-encoder 0.8.0",
- "wasmparser 0.81.0",
+ "wasm-encoder 0.22.0",
+ "wasmparser 0.99.0",
 ]

 [[package]]
@@ -452,18 +558,18 @@ checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

 [[package]]
 name = "wasm-encoder"
-version = "0.8.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db0c351632e46cc06a58a696a6c11e4cf90cad4b9f8f07a0b59128d616c29bb0"
+checksum = "aa9d9bf45fc46f71c407837c9b30b1e874197f2dc357588430b21e5017d290ab"
 dependencies = [
 "leb128",
 ]

 [[package]]
 name = "wasm-encoder"
-version = "0.10.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa9d9bf45fc46f71c407837c9b30b1e874197f2dc357588430b21e5017d290ab"
+checksum = "ef126be0e14bdf355ac1a8b41afc89195289e5c7179f80118e3abddb472f0810"
 dependencies = [
 "leb128",
 ]
@@ -474,18 +580,22 @@ version = "0.77.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b35c86d22e720a07d954ebbed772d01180501afe7d03d464f413bb5f8914a8d6"

-[[package]]
-name = "wasmparser"
-version = "0.81.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98930446519f63d00a836efdc22f67766ceae8dbcc1571379f2bcabc6b2b9abc"
-
 [[package]]
 name = "wasmparser"
 version = "0.83.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "718ed7c55c2add6548cca3ddd6383d738cd73b892df400e96b9aa876f0141d7a"

+[[package]]
+name = "wasmparser"
+version = "0.99.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ef3b717afc67f848f412d4f02c127dd3e35a0eecd58c684580414df4fde01d3"
+dependencies = [
+ "indexmap",
+ "url",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
--- a/platform/Cargo.toml
+++ b/platform/Cargo.toml
@@ -9,4 +9,4 @@ edition = "2021"
 curlywas = { git="https://github.com/exoticorn/curlywas.git", rev="0e7ea50" }
 uw8-tool = { path="../uw8-tool" }
 anyhow = "1"
-lodepng = "3.4"
+lodepng = "3.7.2"
--- a/platform/bin/loader.wasm
+++ b/platform/bin/loader.wasm
--- a/platform/bin/platform.uw8
+++ b/platform/bin/platform.uw8
--- a/platform/src/ges.cwa
+++ b/platform/src/ges.cwa
@@ -10,7 +10,7 @@ const GesState.Size = GesState.Filter + 8*4;
 const GesStateOffset = 32;
 const GesBufferOffset = 32 + GesState.Size;

-export fn gesSnd(t: i32) -> f32 {
+export fn sndGes(t: i32) -> f32 {
    let baseAddr = 0!0x12c78;
    if !(t & 127) {
        let i: i32;
@@ -62,7 +62,6 @@ export fn gesSnd(t: i32) -> f32 {
            let phase = channelState!GesChannelState.Phase;

            let inline pulseWidth = channelReg?1;
-            let phaseShift = (pulseWidth - 128) * 255;
            let invPhaseInc = 1 as f32 / phaseInc as f32;

            i = 0;
@@ -131,7 +130,7 @@ export fn gesSnd(t: i32) -> f32 {
                let phaseInc = (freq * (65536.0 / 44100.0)) as i32;

                let phase = channelState!GesChannelState.Phase;
-                if modSrc > ch {
+                if modSrc < ch {
                    phase = phase - (phaseInc << 6);
                }

--- a/platform/src/platform.cwa
+++ b/platform/src/platform.cwa
@@ -171,7 +171,7 @@ export fn rectangle(x: f32, y: f32, w: f32, h: f32, col: i32) {
    }
 }

-export fn rectangle_outline(x: f32, y: f32, w: f32, h: f32, col: i32) {
+export fn rectangleOutline(x: f32, y: f32, w: f32, h: f32, col: i32) {
    let xl = nearest(x) as i32;
    let xr = nearest(x + w) as i32;
    let yt = nearest(y) as i32;
@@ -212,7 +212,7 @@ export fn circle(cx: f32, cy: f32, radius: f32, col: i32) {
    }
 }

-export fn circle_outline(cx: f32, cy: f32, radius: f32, col: i32) {
+export fn circleOutline(cx: f32, cy: f32, radius: f32, col: i32) {
    let prev_w: f32;
    let y = clamp(nearest(cy - radius) as i32, -1, 241);
    let maxY = clamp(nearest(cy + radius) as i32, -1, 241);
@@ -352,6 +352,92 @@ export fn line(x1: f32, y1: f32, x2: f32, y2: f32, col: i32) {
    setPixel(i32.trunc_sat_f32_s(x1 + f * dx), i32.trunc_sat_f32_s(y1 + f * dy), col);
 }

+export fn blitSprite(sprite: i32, size: i32, x: i32, y: i32, control: i32) {
+    let lazy width = size & 65535;
+    let lazy height = select(size >> 16, size >> 16, width);
+
+    let lazy x0 = select(x < 0, -x, 0);
+    let lazy x1 = select(x + width > 320, 320 - x, width);
+    let lazy y0 = select(y < 0, -y, 0);
+    let lazy y1 = select(y + height > 240, 240 - y, height);
+
+    let lazy numRows = y1 - y0;
+    let lazy numCols = x1 - x0;
+    if numRows <= 0 | numCols <= 0 {
+        return;
+    }
+
+    let trans = (control & 511) - 256;
+    let lazy flip_x = 1 - ((control >> 8) & 2);
+    let lazy flip_y = 1 - ((control >> 9) & 2);
+    if flip_x < 0 {
+        sprite += width - 1;
+    }
+    if flip_y < 0 {
+        sprite += (height - 1) * width;
+    }
+
+    let spriteRow = sprite + x0 * flip_x + y0 * flip_y * width;
+    let screenRow = x + x0 + (y + y0) * 320;
+
+    loop yloop {
+        let lx = 0;
+        loop xloop {
+            let lazy col = (spriteRow + lx * flip_x)?0;
+            if col != trans {
+                (screenRow + lx)?120 = col;
+            }
+            branch_if (lx +:= 1) < numCols: xloop;
+        }
+        spriteRow += width * flip_y;
+        screenRow += 320;
+        branch_if numRows -:= 1: yloop;
+    }
+}
+
+export fn grabSprite(sprite: i32, size: i32, x: i32, y: i32, control: i32) {
+    let lazy width = size & 65535;
+    let lazy height = select(size >> 16, size >> 16, width);
+
+    let lazy x0 = select(x < 0, -x, 0);
+    let lazy x1 = select(x + width > 320, 320 - x, width);
+    let lazy y0 = select(y < 0, -y, 0);
+    let lazy y1 = select(y + height > 240, 240 - y, height);
+
+    let lazy numRows = y1 - y0;
+    let lazy numCols = x1 - x0;
+    if numRows <= 0 | numCols <= 0 {
+        return;
+    }
+
+    let trans = (control & 511) - 256;
+    let lazy flip_x = 1 - ((control >> 8) & 2);
+    let lazy flip_y = 1 - ((control >> 9) & 2);
+    if flip_x < 0 {
+        sprite += width - 1;
+    }
+    if flip_y < 0 {
+        sprite += (height - 1) * width;
+    }
+
+    let spriteRow = sprite + x0 * flip_x + y0 * flip_y * width;
+    let screenRow = x + x0 + (y + y0) * 320;
+
+    loop yloop {
+        let lx = 0;
+        loop xloop {
+            let lazy col = (screenRow + lx)?120;
+            if col != trans {
+                (spriteRow + lx * flip_x)?0 = col;
+            }
+            branch_if (lx +:= 1) < numCols: xloop;
+        }
+        spriteRow += width * flip_y;
+        screenRow += 320;
+        branch_if numRows -:= 1: yloop;
+    }
+}
+
 //////////
 // TEXT //
 //////////
@@ -361,6 +447,7 @@ global mut textCursorY = 0;
 global mut textColor = 15;
 global mut bgColor = 0;
 global mut outputChannel = 0;
+global mut textScale = 1;

 export fn printChar(char: i32) {
    loop chars {
@@ -372,16 +459,9 @@ export fn printChar(char: i32) {
 global mut controlCodeLength = 0;

 fn printSingleChar(char: i32) {
-    if char >= 4 & char <= 6 {
-        outputChannel = char - 4;
-        if !outputChannel {
-            textCursorX = 0;
-            textCursorY = 0;
-        }
-        return;
-    }
+    let charSize = 8 * textScale;

-    if outputChannel >= 2 {
+    if outputChannel >= 2 & (char < 4 | char > 6) {
        logChar(char);
        return;
    }
@@ -399,15 +479,24 @@ fn printSingleChar(char: i32) {
        return;
    }

+    if char >= 4 & char <= 6 {
+        outputChannel = char - 4;
+        if !outputChannel {
+            textCursorX = 0;
+            textCursorY = 0;
+        }
+        return;
+    }
+
    if char == 7 {
        80?0 = 80?0 ^ 2;
        return;
    }

    if char == 8 {
-        textCursorX = textCursorX - 8;
+        textCursorX = textCursorX - charSize;
        if !outputChannel & textCursorX < 0 {
-            textCursorX = 320-8;
+            textCursorX = 320-charSize;
            printSingleChar(11);
        }
        return;
@@ -417,34 +506,34 @@ fn printSingleChar(char: i32) {
        if !outputChannel & textCursorX >= 320 {
            printChar(0xd0a);
        }
-        textCursorX = textCursorX + 8;
+        textCursorX = textCursorX + charSize;
        return;
    }

    if char == 10 {
-        textCursorY = textCursorY + 8;
+        textCursorY = textCursorY + charSize;
        if !outputChannel & textCursorY >= 240 {
-            textCursorY = 240 - 8;
+            textCursorY = 240 - charSize;
            let i: i32;
            loop scroll_copy {
-                i!120 = i!(120 + 320 * 8);
-                branch_if (i := i + 4) < 320 * (240 - 8): scroll_copy;
+                i!120 = (i + 320 * charSize)!120;
+                branch_if (i := i + 4) < 320 * (240 - charSize): scroll_copy;
            }
-            rectangle(0 as f32, (240 - 8) as f32, 320 as f32, 8 as f32, bgColor);
+            rectangle(0 as f32, (240 - charSize) as f32, 320 as f32, charSize as f32, bgColor);
        }
        return;
    }

    if char == 11 {
-        textCursorY = textCursorY - 8;
+        textCursorY = textCursorY - charSize;
        if !outputChannel & textCursorY < 0 {
            textCursorY = 0;
-            let i = 320 * (240 - 8);
+            let i = 320 * (240 - charSize);
            loop scroll_copy {
-                i!(116 + 320 * 8) = i!116;
+                (i + 320 * charSize)!116 = i!116;
                branch_if (i := i - 4): scroll_copy;
            }
-            rectangle(0 as f32, 0 as f32, 320 as f32, 8 as f32, bgColor);
+            rectangle(0 as f32, 0 as f32, 320 as f32, charSize as f32, bgColor);
        }
        return;
    }
@@ -476,6 +565,12 @@ fn printSingleChar(char: i32) {
        return;
    }

+    if char == 30 {
+        let scale = 0x12d20?1;
+        textScale = select(scale > 0 & scale <= 16, scale, 1);
+        return;
+    }
+
    if char == 31 {
        textCursorX = 0x12d20?1 * (8 - outputChannel * 6);
        textCursorY = 0x12d20?2 * (8 - outputChannel * 7);
@@ -498,7 +593,7 @@ data(0x12d00) {
    1, 1, 1, 1, // 16-19,
    1, 1, 1, 1, // 20-23,
    1, 1, 1, 1, // 24-27,
-    1, 1, 1, 3 // 28-31
+    1, 1, 2, 3 // 28-31
  )
 }

@@ -507,26 +602,28 @@ fn drawChar(char: i32) {
        printChar(0xd0a);
    }

+    let charSize = 8 * textScale;
+
    let y: i32;
    loop rows {
-        let bits = (char * 8 + y)?0x13400;
+        let bits = (char * 8 + y / textScale)?0x13400;
        let x = 0;
        if outputChannel {
            loop pixels {
-                if (bits := bits << 1) & 256 {
+                if (bits << (x / textScale)) & 128 {
                    setPixel(textCursorX + x, textCursorY + y, textColor);
                }
-                branch_if (x := x + 1) < 8: pixels;
+                branch_if (x := x + 1) < charSize: pixels;
            }
        } else {
            loop pixels {
-                setPixel(textCursorX + x, textCursorY + y, select((bits := bits << 1) & 256, textColor, bgColor));
-                branch_if (x := x + 1) < 8: pixels;
+                setPixel(textCursorX + x, textCursorY + y, select((bits << (x / textScale)) & 128, textColor, bgColor));
+                branch_if (x := x + 1) < charSize: pixels;
            }
        }
-        branch_if (y := y + 1) < 8: rows;
+        branch_if (y := y + 1) < charSize: rows;
    }
-    textCursorX = textCursorX + 8;
+    textCursorX = textCursorX + charSize;
 }

 export fn printString(ptr: i32) {
--- a/site/content/_index.md
+++ b/site/content/_index.md
@@ -14,6 +14,8 @@ The initial motivation behind MicroW8 was to explore whether there was a way to
 * Memory: 256KB
 * Gamepad input (D-Pad + 4 Buttons)

+For detailed [documentation see here](docs).
+
 ## Examples
 * [Skip Ahead](v0.2.0#AgVfq24KI2Ok2o8qVtPYj27fSuGnfeSKgbOkIOsaEQMov8TDYQ6UjdjwkZrYcM1i9alo4/+Bhm1PRFEa0YHJlJAk/PGoc2K41rejv9ZSqJqIHNjr7cappqhOR2jT+jk+0b0+U6hO+geRCTP2aufWs7L+f/Z27NFY8LKlqPSv+C6Rd6+ohoKi6sYl5Kcrlf1cyTinV7jTTnmbcXWVDBA5rRKxAGMUTDS8rHxqSztRITOaQVP1pSdYgi/BDdOJOxSOIkeaId84S+Ycls5na7EgwSfVIpgqF+tcfkUecb8t2mQrXA7pyKrh/wzHn5N6Oe5aOgmzY2YpTIct) (249 bytes): A port of my [TIC-80 256byte game](http://tic80.com/play?cart=1735) from LoveByte'21, now with sound
 * [Fireworks](v0.2.0#AgwvgP+M59snqjl4CMKw5sqm1Zw9yJCbSviMjeLUdHus2a3yl/a99+uiBeqZgP/2jqSjrLjRk73COMM6OSLpsxK8ugT1kuk/q4hQUqqPpGozHoa0laulzGGcahzdfdJsYaK1sIdeIYS9M5PnJx/Wk9H+PvWEPy2Zvv7I6IW7Fg==) (127 bytes): Some fireworks to welcome 2022.
@@ -29,6 +31,33 @@ Examplers for older versions:

 ## Versions

+### v0.2.2
+
+* [Web runtime](v0.2.2)
+* [Linux](https://github.com/exoticorn/microw8/releases/download/v0.2.2/microw8-0.2.2-linux.tgz)
+* [MacOS](https://github.com/exoticorn/microw8/releases/download/v0.2.2/microw8-0.2.2-macos.tgz)
+* [Windows](https://github.com/exoticorn/microw8/releases/download/v0.2.2/microw8-0.2.2-windows.zip)
+
+Changes:
+
+* call `start` function after loading cart if the cart exports one
+* fix `sndGes` having the wrong name and not being included in the auto imports
+* fix control codes 4-6 (change text output mode) being invoked when used as parameters in other control sequences
+* only open browser window once a cart was compiled sucessfully when running with `-b`
+
+### v0.2.1
+
+* [Web runtime](v0.2.1)
+* [Linux](https://github.com/exoticorn/microw8/releases/download/v0.2.1/microw8-0.2.1-linux.tgz)
+* [MacOS](https://github.com/exoticorn/microw8/releases/download/v0.2.1/microw8-0.2.1-macos.tgz)
+* [Windows](https://github.com/exoticorn/microw8/releases/download/v0.2.1/microw8-0.2.1-windows.zip)
+
+Changes:
+
+* new gpu accelerated renderer with (optional) crt filter
+* optimized `hline` function, a big speed-up when drawing large filled circles or rectangles
+* print fractional size of packed `uw8` cart
+
 ### v0.2.0

 * [Web runtime](v0.2.0)
--- a/site/content/docs.md
+++ b/site/content/docs.md
@@ -5,13 +5,16 @@ description = "Docs"

 # Overview

-MicroW8 loads WebAssembly modules with a maximum size of 256kb. You module needs to export
+MicroW8 loads WebAssembly modules with a maximum size of 256kb. Your module needs to export
 a function `fn upd()` which will be called once per frame.
 After calling `upd` MicroW8 will display the 320x240 8bpp framebuffer located
 at offset 120 in memory with the 32bpp palette located at 0x13000.

 The memory has to be imported as `env` `memory` and has a maximum size of 256kb (4 pages).

+If the module exports a function called `start`, it will be called once after the module is
+loaded.
+
 # Memory map

 ```
@@ -143,13 +146,13 @@ Fills the circle at `cx, cy` and with `radius` with the given color index.

 (Sets all pixels where the pixel center lies inside the circle.)

-### fn rectangle_outline(x: f32, y: f32, w: f32, h: f32, color: i32)
+### fn rectangleOutline(x: f32, y: f32, w: f32, h: f32, color: i32)

 Draws a one pixel outline on the inside of the given rectangle.

 (Draws the outermost pixels that are still inside the rectangle area.)

-### fn circle_outline(cx: f32, cy: f32, radius: f32, color: i32)
+### fn circleOutline(cx: f32, cy: f32, radius: f32, color: i32)

 Draws a one pixel outline on the inside of the given circle.

@@ -159,6 +162,21 @@ Draws a one pixel outline on the inside of the given circle.

 Draws a line from `x1,y1` to `x2,y2` in the given color index.

+### fn blitSprite(spriteData: i32, size: i32, x: i32, y: i32, control: i32)
+
+Copies the pixel data at `spriteData` onto the screen at `x`, `y`. The size of the sprite is passed as `width | (height << 16)`.
+If the height is given as 0, the sprite is is treated as square (width x width).
+
+The control parameter controls masking and flipping of the sprite:
+* bits 0-7: color mask index
+* bit 8: switch on masked blit (pixel with color mask index are treated as transparent)
+* bit 9: flip sprite x
+* bit 10: flip sprite y
+
+### fn grabSprite(spriteData: i32, size: i32, x: i32, y: i32, control: i32)
+
+Copies the pixel data on the screen at `x`, `y` to `spriteData`. Parameters are exactly the same as `blitSprite`.
+
 ## Input

 MicroW8 provides input from a gamepad with one D-Pad and 4 buttons, or a keyboard emulation thereof.
--- a/site/static/v0.2.1/index.html
+++ b/site/static/v0.2.1/index.html
--- a/site/static/v0.2.2/index.html
+++ b/site/static/v0.2.2/index.html
--- a/site/templates/index.html
+++ b/site/templates/index.html
@@ -4,7 +4,7 @@
        <section>
            <h1 class="text-center heading-text">A WebAssembly based fantasy console</h1>
        </section>
-        <a href="v0.2.0">
+        <a href="v0.2.2">
            <img class="demonstration-gif" style="width:640px;height:480px;image-rendering:pixelated" src="img/technotunnel.png"></img>
        </a>
    </div>
--- a/src/filewatcher.rs
+++ b/src/filewatcher.rs
@@ -1,9 +1,13 @@
 use anyhow::{anyhow, bail, Result};
-use notify::{DebouncedEvent, RecommendedWatcher, Watcher};
+use notify_debouncer_mini::{
+    new_debouncer,
+    notify::{self, RecommendedWatcher},
+    DebouncedEvent, DebouncedEventKind, Debouncer,
+};
 use std::{collections::BTreeSet, path::PathBuf, sync::mpsc, time::Duration};

 pub struct FileWatcher {
-    watcher: RecommendedWatcher,
+    debouncer: Debouncer<RecommendedWatcher>,
    watched_files: BTreeSet<PathBuf>,
    directories: BTreeSet<PathBuf>,
    rx: mpsc::Receiver<DebouncedEvent>,
@@ -12,9 +16,18 @@ pub struct FileWatcher {
 impl FileWatcher {
    pub fn new() -> Result<FileWatcher> {
        let (tx, rx) = mpsc::channel();
-        let watcher = notify::watcher(tx, Duration::from_millis(100))?;
+        let debouncer = new_debouncer(Duration::from_millis(100), move |res| match res {
+            Ok(events) => {
+                for event in events {
+                    let _ = tx.send(event);
+                }
+            }
+            Err(err) => {
+                eprintln!("Error watching for file changes: {err}");
+            }
+        })?;
        Ok(FileWatcher {
-            watcher,
+            debouncer,
            watched_files: BTreeSet::new(),
            directories: BTreeSet::new(),
            rx,
@@ -26,7 +39,8 @@ impl FileWatcher {
        let parent = path.parent().ok_or_else(|| anyhow!("File has no parent"))?;

        if !self.directories.contains(parent) {
-            self.watcher
+            self.debouncer
+                .watcher()
                .watch(parent, notify::RecursiveMode::NonRecursive)?;
            self.directories.insert(parent.to_path_buf());
        }
@@ -36,16 +50,18 @@ impl FileWatcher {
    }

    pub fn poll_changed_file(&self) -> Result<Option<PathBuf>> {
-        let event = self.rx.try_recv();
-        match event {
-            Ok(DebouncedEvent::Create(path) | DebouncedEvent::Write(path)) => {
-                let handle = same_file::Handle::from_path(&path)?;
-                for file in &self.watched_files {
-                    if handle == same_file::Handle::from_path(file)? {
-                        return Ok(Some(path));
+        match self.rx.try_recv() {
+            Ok(event) => match event.kind {
+                DebouncedEventKind::Any => {
+                    let handle = same_file::Handle::from_path(&event.path)?;
+                    for file in &self.watched_files {
+                        if handle == same_file::Handle::from_path(file)? {
+                            return Ok(Some(event.path));
+                        }
                    }
                }
-            }
+                _ => (),
+            },
            Err(mpsc::TryRecvError::Disconnected) => bail!("File watcher disconnected"),
            _ => (),
        }
--- a/src/main.rs
+++ b/src/main.rs
@@ -81,11 +81,12 @@ fn run(mut args: Arguments) -> Result<()> {
    #[cfg(not(feature = "native"))]
    let run_browser = args.contains(["-b", "--browser"]) || true;

+    #[allow(unused)]
    let disable_audio = args.contains(["-m", "--no-audio"]);

    #[cfg(feature = "native")]
    let window_config = {
-        let mut config = WindowConfig::default();
+        let mut config = uw8_window::WindowConfig::default();
        if !run_browser {
            config.parse_arguments(&mut args);
        }
@@ -98,8 +99,6 @@ fn run(mut args: Arguments) -> Result<()> {

    use std::process::exit;

-    use uw8_window::WindowConfig;
-
    let mut runtime: Box<dyn Runtime> = if !run_browser {
        #[cfg(not(feature = "native"))]
        unimplemented!();
--- a/src/run-web.html
+++ b/src/run-web.html
--- a/src/run_native.rs
+++ b/src/run_native.rs
@@ -7,7 +7,7 @@ use cpal::traits::*;
 use rubato::Resampler;
 use uw8_window::{Window, WindowConfig};
 use wasmtime::{
-    Engine, GlobalType, Memory, MemoryType, Module, Mutability, Store, TypedFunc, ValType,
+    Engine, Func, GlobalType, Memory, MemoryType, Module, Mutability, Store, TypedFunc, ValType,
 };

 pub struct MicroW8 {
@@ -90,10 +90,10 @@ impl super::Runtime for MicroW8 {
        let memory = wasmtime::Memory::new(&mut store, MemoryType::new(4, Some(4)))?;

        let mut linker = wasmtime::Linker::new(&self.engine);
-        linker.define("env", "memory", memory)?;
+        linker.define(&store, "env", "memory", memory)?;

        let loader_instance = linker.instantiate(&mut store, &self.loader_module)?;
-        let load_uw8 = loader_instance.get_typed_func::<i32, i32, _>(&mut store, "load_uw8")?;
+        let load_uw8 = loader_instance.get_typed_func::<i32, i32>(&mut store, "load_uw8")?;

        let platform_data = include_bytes!("../platform/bin/platform.uw8");
        memory.data_mut(&mut store)[..platform_data.len()].copy_from_slice(platform_data);
@@ -131,8 +131,12 @@ impl super::Runtime for MicroW8 {
        }

        let instance = linker.instantiate(&mut store, &module)?;
-        let end_frame = platform_instance.get_typed_func::<(), (), _>(&mut store, "endFrame")?;
-        let update = instance.get_typed_func::<(), (), _>(&mut store, "upd").ok();
+        let end_frame = platform_instance.get_typed_func::<(), ()>(&mut store, "endFrame")?;
+        let update = instance.get_typed_func::<(), ()>(&mut store, "upd").ok();
+
+        if let Some(start) = instance.get_typed_func::<(), ()>(&mut store, "start").ok() {
+            start.call(&mut store, ())?;
+        }

        let (sound_tx, stream) = if self.disable_audio {
            (None, None)
@@ -251,15 +255,12 @@ fn add_native_functions(
        }
    })?;
    for i in 0..16 {
-        linker.define(
-            "env",
-            &format!("g_reserved{}", i),
-            wasmtime::Global::new(
-                &mut *store,
-                GlobalType::new(ValType::I32, Mutability::Const),
-                0.into(),
-            )?,
+        let global = wasmtime::Global::new(
+            &mut *store,
+            GlobalType::new(ValType::I32, Mutability::Const),
+            0.into(),
        )?;
+        linker.define(&store, "env", &format!("g_reserved{}", i), global)?;
    }

    Ok(())
@@ -272,14 +273,18 @@ fn instantiate_platform(
 ) -> Result<wasmtime::Instance> {
    let platform_instance = linker.instantiate(&mut *store, &platform_module)?;

-    for export in platform_instance.exports(&mut *store) {
-        linker.define(
-            "env",
-            export.name(),
-            export
-                .into_func()
-                .expect("platform surely only exports functions"),
-        )?;
+    let exports: Vec<(String, Func)> = platform_instance
+        .exports(&mut *store)
+        .map(|e| {
+            (
+                e.name().to_owned(),
+                e.into_func()
+                    .expect("platform surely only exports functions"),
+            )
+        })
+        .collect();
+    for (name, func) in exports {
+        linker.define(&store, "env", &name, func)?;
    }

    Ok(platform_instance)
@@ -306,15 +311,15 @@ fn init_sound(
    let memory = wasmtime::Memory::new(&mut store, MemoryType::new(4, Some(4)))?;

    let mut linker = wasmtime::Linker::new(engine);
-    linker.define("env", "memory", memory)?;
+    linker.define(&store, "env", "memory", memory)?;
    add_native_functions(&mut linker, &mut store)?;

    let platform_instance = instantiate_platform(&mut linker, &mut store, platform_module)?;
    let instance = linker.instantiate(&mut store, module)?;

    let snd = instance
-        .get_typed_func::<(i32,), f32, _>(&mut store, "snd")
-        .or_else(|_| platform_instance.get_typed_func::<(i32,), f32, _>(&mut store, "gesSnd"))?;
+        .get_typed_func::<(i32,), f32>(&mut store, "snd")
+        .or_else(|_| platform_instance.get_typed_func::<(i32,), f32>(&mut store, "sndGes"))?;

    let host = cpal::default_host();
    let device = host
@@ -323,26 +328,29 @@ fn init_sound(
    let mut configs: Vec<_> = device
        .supported_output_configs()?
        .filter(|config| {
-            config.channels() == 2 && config.sample_format() == cpal::SampleFormat::F32
+            config.channels() == 2
+                && (config.sample_format() == cpal::SampleFormat::F32
+                    || config.sample_format() == cpal::SampleFormat::I16)
        })
        .collect();
    configs.sort_by_key(|config| {
        let rate = 44100
            .max(config.min_sample_rate().0)
            .min(config.max_sample_rate().0);
-        if rate >= 44100 {
+        let prio = if rate >= 44100 {
            rate - 44100
        } else {
            (44100 - rate) * 1000
-        }
+        };
+        prio + (config.sample_format() == cpal::SampleFormat::I16) as u32
    });
    let config = configs
        .into_iter()
        .next()
-        .ok_or_else(|| anyhow!("Could not find float output config"))?;
+        .ok_or_else(|| anyhow!("Could not find float or 16bit signed output config"))?;
    let sample_rate = cpal::SampleRate(44100)
        .max(config.min_sample_rate())
-        .max(config.max_sample_rate());
+        .min(config.max_sample_rate());
    let config = config.with_sample_rate(sample_rate);
    let buffer_size = match *config.buffer_size() {
        cpal::SupportedBufferSize::Unknown => cpal::BufferSize::Default,
@@ -350,6 +358,7 @@ fn init_sound(
            cpal::BufferSize::Fixed(256.max(min).min(max))
        }
    };
+    let sample_format = config.sample_format();
    let config = cpal::StreamConfig {
        buffer_size,
        ..config.config()
@@ -369,8 +378,8 @@ fn init_sound(
        None
    } else {
        let rs = rubato::FftFixedIn::new(44100, sample_rate, 128, 1, 2)?;
-        let input_buffers = rs.input_buffer_allocate();
-        let output_buffers = rs.output_buffer_allocate();
+        let input_buffers = rs.input_buffer_allocate(true);
+        let output_buffers = rs.output_buffer_allocate(true);
        Some(Resampler {
            resampler: rs,
            input_buffers,
@@ -382,96 +391,130 @@ fn init_sound(
    let mut sample_index = 0;
    let mut pending_updates: Vec<RegisterUpdate> = Vec::with_capacity(30);
    let mut current_time = 0;
-    let stream = device.build_output_stream(
-        &config,
-        move |mut outer_buffer: &mut [f32], _| {
-            let mut first_update = true;
-            while let Ok(update) = rx.try_recv() {
-                if first_update {
-                    current_time += update.time.wrapping_sub(current_time) / 8;
-                    first_update = false;
-                }
-                pending_updates.push(update);
+
+    let mut callback = move |mut outer_buffer: &mut [f32], _: &_| {
+        let mut first_update = true;
+        while let Ok(update) = rx.try_recv() {
+            if first_update {
+                current_time += update.time.wrapping_sub(current_time) / 8;
+                first_update = false;
+            }
+            pending_updates.push(update);
+        }
+
+        while !outer_buffer.is_empty() {
+            store.set_epoch_deadline(30);
+            while pending_updates
+                .first()
+                .into_iter()
+                .any(|u| u.time.wrapping_sub(current_time) <= 0)
+            {
+                let update = pending_updates.remove(0);
+                memory.write(&mut store, 80, &update.data).unwrap();
            }

-            while !outer_buffer.is_empty() {
-                store.set_epoch_deadline(30);
-                while pending_updates
-                    .first()
-                    .into_iter()
-                    .any(|u| u.time.wrapping_sub(current_time) <= 0)
-                {
-                    let update = pending_updates.remove(0);
-                    memory.write(&mut store, 80, &update.data).unwrap();
-                }
+            let duration = if let Some(update) = pending_updates.first() {
+                ((update.time.wrapping_sub(current_time) as usize) * sample_rate + 999) / 1000
+            } else {
+                outer_buffer.len()
+            };
+            let step_size = (duration.max(64) * 2).min(outer_buffer.len());

-                let duration = if let Some(update) = pending_updates.first() {
-                    ((update.time.wrapping_sub(current_time) as usize) * sample_rate + 999) / 1000
+            let mut buffer = &mut outer_buffer[..step_size];
+
+            {
+                let mem = memory.data_mut(&mut store);
+                mem[64..68].copy_from_slice(&current_time.to_le_bytes());
+            }
+
+            fn clamp_sample(s: f32) -> f32 {
+                if s.is_nan() {
+                    0.0
                } else {
-                    outer_buffer.len()
-                };
-                let step_size = (duration.max(64) * 2).min(outer_buffer.len());
-
-                let mut buffer = &mut outer_buffer[..step_size];
-
-                {
-                    let mem = memory.data_mut(&mut store);
-                    mem[64..68].copy_from_slice(&current_time.to_le_bytes());
+                    s.max(-1.0).min(1.0)
                }
+            }

-                if let Some(ref mut resampler) = resampler {
-                    while !buffer.is_empty() {
-                        let copy_size = resampler.output_buffers[0]
-                            .len()
-                            .saturating_sub(resampler.output_index)
-                            .min(buffer.len() / 2);
-                        if copy_size == 0 {
-                            resampler.input_buffers[0].clear();
-                            resampler.input_buffers[1].clear();
-                            for _ in 0..resampler.resampler.input_frames_next() {
-                                resampler.input_buffers[0]
-                                    .push(snd.call(&mut store, (sample_index,)).unwrap_or(0.0));
-                                resampler.input_buffers[1]
-                                    .push(snd.call(&mut store, (sample_index + 1,)).unwrap_or(0.0));
-                                sample_index = sample_index.wrapping_add(2);
-                            }
-
-                            resampler
-                                .resampler
-                                .process_into_buffer(
-                                    &resampler.input_buffers,
-                                    &mut resampler.output_buffers,
-                                    None,
-                                )
-                                .unwrap();
-                            resampler.output_index = 0;
-                        } else {
-                            for i in 0..copy_size {
-                                buffer[i * 2] =
-                                    resampler.output_buffers[0][resampler.output_index + i];
-                                buffer[i * 2 + 1] =
-                                    resampler.output_buffers[1][resampler.output_index + i];
-                            }
-                            resampler.output_index += copy_size;
-                            buffer = &mut buffer[copy_size * 2..];
+            if let Some(ref mut resampler) = resampler {
+                while !buffer.is_empty() {
+                    let copy_size = resampler.output_buffers[0]
+                        .len()
+                        .saturating_sub(resampler.output_index)
+                        .min(buffer.len() / 2);
+                    if copy_size == 0 {
+                        resampler.input_buffers[0].clear();
+                        resampler.input_buffers[1].clear();
+                        for _ in 0..resampler.resampler.input_frames_next() {
+                            resampler.input_buffers[0].push(clamp_sample(
+                                snd.call(&mut store, (sample_index,)).unwrap_or(0.0),
+                            ));
+                            resampler.input_buffers[1].push(clamp_sample(
+                                snd.call(&mut store, (sample_index + 1,)).unwrap_or(0.0),
+                            ));
+                            sample_index = sample_index.wrapping_add(2);
                        }
-                    }
-                } else {
-                    for v in buffer {
-                        *v = snd.call(&mut store, (sample_index,)).unwrap_or(0.0);
-                        sample_index = sample_index.wrapping_add(1);
+
+                        resampler
+                            .resampler
+                            .process_into_buffer(
+                                &resampler.input_buffers,
+                                &mut resampler.output_buffers,
+                                None,
+                            )
+                            .unwrap();
+                        resampler.output_index = 0;
+                    } else {
+                        for i in 0..copy_size {
+                            buffer[i * 2] = resampler.output_buffers[0][resampler.output_index + i];
+                            buffer[i * 2 + 1] =
+                                resampler.output_buffers[1][resampler.output_index + i];
+                        }
+                        resampler.output_index += copy_size;
+                        buffer = &mut buffer[copy_size * 2..];
                    }
                }
-
-                outer_buffer = &mut outer_buffer[step_size..];
-                current_time =
-                    current_time.wrapping_add((step_size * 500 / sample_rate).max(1) as i32);
+            } else {
+                for v in buffer {
+                    *v = clamp_sample(snd.call(&mut store, (sample_index,)).unwrap_or(0.0));
+                    sample_index = sample_index.wrapping_add(1);
+                }
            }
-        },
-        move |err| {
-            dbg!(err);
-        },
-    )?;
+
+            outer_buffer = &mut outer_buffer[step_size..];
+            current_time = current_time.wrapping_add((step_size * 500 / sample_rate).max(1) as i32);
+        }
+    };
+    let stream = if sample_format == cpal::SampleFormat::F32 {
+        device.build_output_stream(
+            &config,
+            callback,
+            move |err| {
+                dbg!(err);
+            },
+            None,
+        )?
+    } else {
+        device.build_output_stream(
+            &config,
+            move |mut buffer: &mut [i16], info| {
+                let mut float_buffer = [0f32; 256];
+
+                while !buffer.is_empty() {
+                    let step_size = buffer.len().min(float_buffer.len());
+                    let step_buffer = &mut float_buffer[..step_size];
+                    callback(step_buffer, info);
+                    for (dest, src) in buffer.iter_mut().take(step_size).zip(step_buffer.iter()) {
+                        *dest = (src.max(-1.0).min(1.0) * 32767.0) as i16;
+                    }
+                    buffer = &mut buffer[step_size..];
+                }
+            },
+            move |err| {
+                dbg!(err);
+            },
+            None,
+        )?
+    };

    Ok(Uw8Sound { stream, tx })
 }
--- a/src/run_web.rs
+++ b/src/run_web.rs
@@ -11,6 +11,7 @@ use warp::{http::Response, Filter};
 pub struct RunWebServer {
    cart: Arc<Mutex<Vec<u8>>>,
    tx: broadcast::Sender<()>,
+    socket_addr: SocketAddr,
 }

 impl RunWebServer {
@@ -18,8 +19,13 @@ impl RunWebServer {
        let cart = Arc::new(Mutex::new(Vec::new()));
        let (tx, _) = broadcast::channel(1);

+        let socket_addr = "127.0.0.1:3030"
+            .parse::<SocketAddr>()
+            .expect("Failed to parse socket address");
+
        let server_cart = cart.clone();
        let server_tx = tx.clone();
+        let server_addr = socket_addr.clone();
        thread::spawn(move || {
            let rt = tokio::runtime::Builder::new_current_thread()
                .enable_io()
@@ -47,24 +53,26 @@ impl RunWebServer {
                    warp::sse::reply(warp::sse::keep_alive().stream(event_stream(&server_tx)))
                });

-                let socket_addr = "127.0.0.1:3030"
-                    .parse::<SocketAddr>()
-                    .expect("Failed to parse socket address");
-
-                let server_future = warp::serve(html.or(cart).or(events)).bind(socket_addr);
-                println!("Point browser at http://{}", socket_addr);
-                let _ignore_result = webbrowser::open(&format!("http://{}", socket_addr));
+                let server_future = warp::serve(html.or(cart).or(events)).bind(server_addr);
                server_future.await
            });
        });

-        RunWebServer { cart, tx }
+        RunWebServer {
+            cart,
+            tx,
+            socket_addr,
+        }
    }
 }

 impl super::Runtime for RunWebServer {
    fn load(&mut self, module_data: &[u8]) -> Result<()> {
        if let Ok(mut lock) = self.cart.lock() {
+            if lock.is_empty() && !module_data.is_empty() {
+                println!("Point browser at http://{}", self.socket_addr);
+                let _ignore_result = webbrowser::open(&format!("http://{}", self.socket_addr));
+            }
            lock.clear();
            lock.extend_from_slice(module_data);
        }
@@ -86,4 +94,4 @@ impl Default for RunWebServer {
    fn default() -> RunWebServer {
        RunWebServer::new()
    }
-}
+}
--- a/test.cwa
+++ b/test.cwa
@@ -1,13 +0,0 @@
-import "env.memory" memory(4);
-import "env.printString" fn print(i32);
-
-export fn upd() {
-}
-
-start fn start() {
-    print(0);
-}
-
-data 0 {
-    "Press " i8(0xe0) " and " i8(0xe1) " to adjust, " i8(0xcc) " to commit." i8(0)
-}
--- a/test.wasm
+++ b/test.wasm
--- a/test/ges_test.cwa
+++ b/test/ges_test.cwa
@@ -2,17 +2,18 @@ import "env.memory" memory(4);
 import "env.pow" fn pow(f32, f32) -> f32;
 import "env.sin" fn sin(f32) -> f32;
 import "env.cls" fn cls(i32);
+import "env.exp" fn exp(f32) -> f32;
 import "env.rectangle" fn rectangle(f32, f32, f32, f32, i32);

 include "../platform/src/ges.cwa"

 export fn snd(t: i32) -> f32 {
-    gesSnd(t)
+    sndGes(t)
 }

 export fn upd() {
    80?0 = 32!32 / 200 & 2 | 0x41;
-    80?3 = (32!32 / 400)%7*12/7 + 40;
+    80?3 = (32!32 / 400)%8*12/7 + 40;
    let pulse = (32!32 * 256 / 2000) & 511;
    if pulse >= 256 {
        pulse = 511 - pulse;
--- a/test/start_fn.cwa
+++ b/test/start_fn.cwa
@@ -0,0 +1,5 @@
+include "../examples/include/microw8-api.cwa"
+
+export fn start() {
+	printChar('Test');
+}
--- a/test/text_modes.cwa
+++ b/test/text_modes.cwa
@@ -0,0 +1,13 @@
+include "../examples/include/microw8-api.cwa"
+
+export fn upd() {
+	printString(USER_MEM);
+}
+
+data USER_MEM {
+	i8(12, 31, 5, 6) "Text mode"
+	i8(5, 31, 4, 5) "Graphics mode"
+	i8(6) "Console output\nSecond line\n"
+	i8(4, 31, 4, 12) "Back to text mode"
+	i8(0)
+}
--- a/todo.txt
+++ b/todo.txt
@@ -0,0 +1 @@
+* add support for 16bit sound (not just float)
--- a/uw8-tool/Cargo.lock
+++ b/uw8-tool/Cargo.lock
@@ -56,6 +56,21 @@ dependencies = [
 "lazy_static",
 ]

+[[package]]
+name = "form_urlencoded"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
 [[package]]
 name = "heck"
 version = "0.3.3"
@@ -71,6 +86,26 @@ version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"

+[[package]]
+name = "idna"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -83,6 +118,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"

+[[package]]
+name = "lexopt"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "478ee9e62aaeaf5b140bd4138753d1f109765488581444218d3ddda43234f3e8"
+
 [[package]]
 name = "libc"
 version = "0.2.112"
@@ -120,10 +161,16 @@ dependencies = [
 ]

 [[package]]
-name = "pico-args"
-version = "0.4.2"
+name = "percent-encoding"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"
+checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+
+[[package]]
+name = "pico-args"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"

 [[package]]
 name = "proc-macro2"
@@ -163,6 +210,26 @@ dependencies = [
 "unicode-xid",
 ]

+[[package]]
+name = "thiserror"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "time"
 version = "0.1.44"
@@ -174,6 +241,36 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "tinyvec"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d54675592c1dbefd78cbd98db9bacd89886e1ca50692a0692baefffdeb92dd58"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
+dependencies = [
+ "tinyvec",
+]
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.8.0"
@@ -188,13 +285,24 @@ checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"

 [[package]]
 name = "upkr"
-version = "0.1.0"
-source = "git+https://github.com/exoticorn/upkr.git?rev=d93aec186c9fb91d962c488682a2db125c61306c#d93aec186c9fb91d962c488682a2db125c61306c"
+version = "0.2.1"
+source = "git+https://github.com/exoticorn/upkr.git?rev=080db40d0088bbee2bdf3c5c75288ac7853d6b7a#080db40d0088bbee2bdf3c5c75288ac7853d6b7a"
 dependencies = [
 "anyhow",
 "cdivsufsort",
- "pbr",
- "pico-args",
+ "lexopt",
+ "thiserror",
+]
+
+[[package]]
+name = "url"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
 ]

 [[package]]
@@ -207,7 +315,7 @@ dependencies = [
 "upkr",
 "walrus",
 "wasm-encoder",
- "wasmparser 0.81.0",
+ "wasmparser 0.99.0",
 ]

 [[package]]
@@ -244,9 +352,9 @@ checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"

 [[package]]
 name = "wasm-encoder"
-version = "0.8.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db0c351632e46cc06a58a696a6c11e4cf90cad4b9f8f07a0b59128d616c29bb0"
+checksum = "ef126be0e14bdf355ac1a8b41afc89195289e5c7179f80118e3abddb472f0810"
 dependencies = [
 "leb128",
 ]
@@ -259,9 +367,13 @@ checksum = "b35c86d22e720a07d954ebbed772d01180501afe7d03d464f413bb5f8914a8d6"

 [[package]]
 name = "wasmparser"
-version = "0.81.0"
+version = "0.99.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98930446519f63d00a836efdc22f67766ceae8dbcc1571379f2bcabc6b2b9abc"
+checksum = "9ef3b717afc67f848f412d4f02c127dd3e35a0eecd58c684580414df4fde01d3"
+dependencies = [
+ "indexmap",
+ "url",
+]

 [[package]]
 name = "winapi"
--- a/uw8-tool/Cargo.toml
+++ b/uw8-tool/Cargo.toml
@@ -6,10 +6,10 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-wasmparser = "0.81"
-wasm-encoder = "0.8"
+wasmparser = "0.99"
+wasm-encoder = "0.22"
 walrus = "0.19"
 anyhow = "1"
-pico-args = "0.4"
-upkr = { git = "https://github.com/exoticorn/upkr.git", rev = "d93aec186c9fb91d962c488682a2db125c61306c" }
+pico-args = "0.5"
+upkr = { git = "https://github.com/exoticorn/upkr.git", rev = "080db40d0088bbee2bdf3c5c75288ac7853d6b7a" }
 pbr = "1"
--- a/uw8-tool/src/base_module.rs
+++ b/uw8-tool/src/base_module.rs
@@ -3,7 +3,7 @@ use std::{collections::HashMap, fs::File, path::Path};
 use anyhow::{bail, Result};
 use std::io::prelude::*;
 use wasm_encoder::{
-    CodeSection, EntityType, Export, ExportSection, Function, FunctionSection, ImportSection,
+    CodeSection, EntityType, ExportKind, ExportSection, Function, FunctionSection, ImportSection,
    Instruction, MemoryType, Module, TypeSection, ValType,
 };
 use ValType::*;
@@ -152,14 +152,14 @@ impl BaseModule {
        add_function(
            &mut functions,
            &type_map,
-            "rectangle_outline",
+            "rectangleOutline",
            &[F32, F32, F32, F32, I32],
            None,
        );
        add_function(
            &mut functions,
            &type_map,
-            "circle_outline",
+            "circleOutline",
            &[F32, F32, F32, I32],
            None,
        );
@@ -167,6 +167,22 @@ impl BaseModule {
        add_function(&mut functions, &type_map, "exp", &[F32], Some(F32));

        add_function(&mut functions, &type_map, "playNote", &[I32, I32], None);
+        add_function(&mut functions, &type_map, "sndGes", &[I32], Some(F32));
+
+        add_function(
+            &mut functions,
+            &type_map,
+            "blitSprite",
+            &[I32, I32, I32, I32, I32],
+            None,
+        );
+        add_function(
+            &mut functions,
+            &type_map,
+            "grabSprite",
+            &[I32, I32, I32, I32, I32],
+            None,
+        );

        for i in functions.len()..64 {
            add_function(
@@ -217,13 +233,13 @@ impl BaseModule {
            let mut imports = ImportSection::new();

            for (module, name, type_) in &self.function_imports {
-                imports.import(*module, Some(name.as_str()), EntityType::Function(*type_));
+                imports.import(*module, name.as_str(), EntityType::Function(*type_));
            }

            for (module, name, import) in &self.global_imports {
                imports.import(
                    *module,
-                    Some(name.as_str()),
+                    name.as_str(),
                    EntityType::Global(wasm_encoder::GlobalType {
                        val_type: import.type_,
                        mutable: import.mutable,
@@ -233,11 +249,12 @@ impl BaseModule {

            imports.import(
                "env",
-                Some("memory"),
+                "memory",
                MemoryType {
                    minimum: self.memory as u64,
                    maximum: None,
                    memory64: false,
+                    shared: false,
                },
            );

@@ -258,7 +275,7 @@ impl BaseModule {
            let mut exports = ExportSection::new();

            for (name, fnc) in &self.exports {
-                exports.export(*name, Export::Function(*fnc));
+                exports.export(*name, ExportKind::Func, *fnc);
            }

            module.section(&exports);
@@ -286,7 +303,7 @@ impl BaseModule {

    pub fn create_binary(path: &Path) -> Result<()> {
        let base1 = BaseModule::for_format_version(1)?.to_wasm();
-        let data = upkr::pack(&base1, 4, false, None);
+        let data = upkr::pack(&base1, 4, &upkr::Config::default(), None);
        File::create(path)?.write_all(&data)?;
        Ok(())
    }
--- a/uw8-tool/src/filter_exports.rs
+++ b/uw8-tool/src/filter_exports.rs
@@ -1,13 +1,17 @@
-use std::path::Path;
 use anyhow::Result;
+use std::path::Path;

 pub fn filter_exports(in_path: &Path, out_path: &Path) -> Result<()> {
    let mut module = walrus::Module::from_file(in_path)?;

-    let exports_to_delete: Vec<_> = module.exports.iter().filter_map(|export| match export.name.as_str() {
-        "upd" => None,
-        _ => Some(export.id())
-    }).collect();
+    let exports_to_delete: Vec<_> = module
+        .exports
+        .iter()
+        .filter_map(|export| match export.name.as_str() {
+            "start" | "upd" | "snd" => None,
+            _ => Some(export.id()),
+        })
+        .collect();

    for id in exports_to_delete {
        module.exports.delete(id);
@@ -18,4 +22,4 @@ pub fn filter_exports(in_path: &Path, out_path: &Path) -> Result<()> {
    module.emit_wasm_file(out_path)?;

    Ok(())
-}
+}
--- a/uw8-tool/src/pack.rs
+++ b/uw8-tool/src/pack.rs
@@ -10,7 +10,7 @@ use std::{
 use wasm_encoder as enc;
 use wasmparser::{
    BinaryReader, ExportSectionReader, ExternalKind, FunctionBody, FunctionSectionReader,
-    ImportSectionEntryType, ImportSectionReader, TableSectionReader, TypeSectionReader,
+    ImportSectionReader, TableSectionReader, TypeRef, TypeSectionReader,
 };

 pub struct PackConfig {
@@ -63,7 +63,7 @@ pub fn pack(data: &[u8], config: &PackConfig) -> Result<Vec<u8>> {
        uw8.extend_from_slice(&upkr::pack(
            &result[8..],
            level,
-            false,
+            &upkr::Config::default(),
            Some(&mut |pos| {
                pb.set(pos as u64);
            }),
@@ -90,7 +90,10 @@ pub fn unpack(data: Vec<u8>) -> Result<Vec<u8>> {
    let (version, data) = match data[0] {
        0 => return Ok(data),
        1 => (1, data[1..].to_vec()),
-        2 => (1, upkr::unpack(&data[1..], false)),
+        2 => (
+            1,
+            upkr::unpack(&data[1..], &upkr::Config::default(), 4 * 1024 * 1024)?,
+        ),
        other => bail!("Uknown format version {}", other),
    };

@@ -133,8 +136,8 @@ pub fn unpack(data: Vec<u8>) -> Result<Vec<u8>> {
    Ok(dest)
 }

-fn to_val_type(type_: &wasmparser::Type) -> Result<ValType> {
-    use wasmparser::Type::*;
+fn to_val_type(type_: &wasmparser::ValType) -> Result<ValType> {
+    use wasmparser::ValType::*;
    Ok(match *type_ {
        I32 => ValType::I32,
        I64 => ValType::I64,
@@ -144,7 +147,7 @@ fn to_val_type(type_: &wasmparser::Type) -> Result<ValType> {
    })
 }

-fn to_val_type_vec(types: &[wasmparser::Type]) -> Result<Vec<ValType>> {
+fn to_val_type_vec(types: &[wasmparser::ValType]) -> Result<Vec<ValType>> {
    types.into_iter().map(to_val_type).collect()
 }

@@ -202,7 +205,7 @@ impl<'a> ParsedModule<'a> {
                    import_section = Some(Section::new(range, ImportSection::parse(reader)?));
                }
                Payload::GlobalSection(reader) => {
-                    global_section = Some(Section::new(range, reader.get_count()));
+                    global_section = Some(Section::new(range, reader.count()));
                }
                Payload::FunctionSection(reader) => {
                    function_section = Some(Section::new(range, read_function_section(reader)?));
@@ -220,17 +223,22 @@ impl<'a> ParsedModule<'a> {
                    validate_table_section(reader)?;
                    table_section = Some(Section::new(range, ()));
                }
-                Payload::ElementSection(mut reader) => {
-                    let mut elements = Vec::with_capacity(reader.get_count() as usize);
-                    for _ in 0..reader.get_count() {
-                        elements.push(Element::parse(reader.read()?)?);
+                Payload::MemorySection(reader) => {
+                    if reader.count() != 0 {
+                        bail!("Found non-empty MemorySection. Memory has to be imported!");
+                    }
+                }
+                Payload::ElementSection(reader) => {
+                    let mut elements = Vec::with_capacity(reader.count() as usize);
+                    for element in reader {
+                        elements.push(Element::parse(element?)?);
                    }
                    element_section = Some(elements);
                }
                Payload::CodeSectionStart { .. } => (),
                Payload::CodeSectionEntry(body) => function_bodies.push(body),
                Payload::CustomSection { .. } => (),
-                Payload::End => break,
+                Payload::End(..) => break,
                other => bail!("Unsupported section: {:?}", other),
            }

@@ -458,7 +466,7 @@ impl<'a> ParsedModule<'a> {
            {
                let mut export_section = enc::ExportSection::new();
                for (name, fnc) in my_exports {
-                    export_section.export(&name, enc::Export::Function(fnc));
+                    export_section.export(&name, enc::ExportKind::Func, fnc);
                }
                module.section(&export_section);
            }
@@ -481,7 +489,7 @@ impl<'a> ParsedModule<'a> {
                }
                element_section.active(
                    None,
-                    &wasm_encoder::Instruction::I32Const(element.start_index as i32),
+                    &wasm_encoder::ConstExpr::i32_const(element.start_index as i32),
                    ValType::FuncRef,
                    wasm_encoder::Elements::Functions(&functions),
                );
@@ -530,28 +538,27 @@ fn read_type_section(reader: TypeSectionReader) -> Result<Vec<base_module::Funct

    for type_def in reader {
        match type_def? {
-            wasmparser::TypeDef::Func(fnc) => {
-                if fnc.returns.len() > 1 {
+            wasmparser::Type::Func(fnc) => {
+                if fnc.results().len() > 1 {
                    bail!("Multi-value not supported");
                }
-                let params = to_val_type_vec(&fnc.params)?;
-                let result = to_val_type_vec(&fnc.returns)?.into_iter().next();
+                let params = to_val_type_vec(fnc.params())?;
+                let result = to_val_type_vec(fnc.results())?.into_iter().next();
                function_types.push(FunctionType { params, result });
            }
-            t => bail!("Unsupported type def {:?}", t),
        }
    }

    Ok(function_types)
 }

-fn validate_table_section(mut reader: TableSectionReader) -> Result<()> {
-    if reader.get_count() != 1 {
+fn validate_table_section(reader: TableSectionReader) -> Result<()> {
+    if reader.count() != 1 {
        bail!("Only up to one table supported");
    }

-    let type_ = reader.read()?;
-    if type_.element_type != wasmparser::Type::FuncRef {
+    let type_ = reader.into_iter().next().unwrap()?;
+    if type_.element_type != wasmparser::ValType::FuncRef {
        bail!("Only one funcref table is supported");
    }

@@ -585,45 +592,38 @@ impl ImportSection {

        for import in reader {
            let import = import?;
-            if let Some(field) = import.field {
-                match import.ty {
-                    ImportSectionEntryType::Function(type_) => {
-                        functions.push(FunctionImport {
-                            module: import.module.to_string(),
-                            field: field.to_string(),
-                            type_,
-                        });
-                    }
-                    ImportSectionEntryType::Memory(mem) => {
-                        if import.module != "env" || field != "memory" {
-                            bail!(
-                                "Wrong name of memory import {}.{}, should be env.memory",
-                                import.module,
-                                field
-                            );
-                        }
-                        if mem.memory64 || mem.shared {
-                            bail!("Wrong memory import options: {:?}", import.ty);
-                        }
-                        memory = mem.maximum.unwrap_or(mem.initial) as u32;
-                    }
-                    ImportSectionEntryType::Global(glbl) => {
-                        globals.push(GlobalImport {
-                            module: import.module.to_string(),
-                            field: field.to_string(),
-                            type_: GlobalType {
-                                type_: to_val_type(&glbl.content_type)?,
-                                mutable: glbl.mutable,
-                            },
-                        });
-                    }
-                    _ => bail!("Unsupported import item {:?}", import.ty),
+            match import.ty {
+                TypeRef::Func(type_) => {
+                    functions.push(FunctionImport {
+                        module: import.module.to_string(),
+                        field: import.name.to_string(),
+                        type_,
+                    });
                }
-            } else {
-                bail!(
-                    "Found import without field, only module '{}'",
-                    import.module
-                );
+                TypeRef::Memory(mem) => {
+                    if import.module != "env" || import.name != "memory" {
+                        bail!(
+                            "Wrong name of memory import {}.{}, should be env.memory",
+                            import.module,
+                            import.name
+                        );
+                    }
+                    if mem.memory64 || mem.shared {
+                        bail!("Wrong memory import options: {:?}", import.ty);
+                    }
+                    memory = mem.maximum.unwrap_or(mem.initial) as u32;
+                }
+                TypeRef::Global(glbl) => {
+                    globals.push(GlobalImport {
+                        module: import.module.to_string(),
+                        field: import.name.to_string(),
+                        type_: GlobalType {
+                            type_: to_val_type(&glbl.content_type)?,
+                            mutable: glbl.mutable,
+                        },
+                    });
+                }
+                _ => bail!("Unsupported import item {:?}", import.ty),
            }
        }

@@ -643,40 +643,37 @@ struct Element {

 impl Element {
    fn parse(element: wasmparser::Element) -> Result<Element> {
-        if element.ty != wasmparser::Type::FuncRef {
-            bail!("Table element type is not FuncRef");
-        }
+        match element.items {
+            wasmparser::ElementItems::Functions(funcs_reader) => {
+                let start_index = if let wasmparser::ElementKind::Active {
+                    offset_expr,
+                    table_index: 0,
+                } = element.kind
+                {
+                    let mut init_reader = offset_expr.get_operators_reader();
+                    if let wasmparser::Operator::I32Const { value: start_index } =
+                        init_reader.read()?
+                    {
+                        start_index as u32
+                    } else {
+                        bail!("Table element start index is not a integer constant");
+                    }
+                } else {
+                    bail!("Unsupported table element kind");
+                };

-        let start_index = if let wasmparser::ElementKind::Active {
-            init_expr,
-            table_index: 0,
-        } = element.kind
-        {
-            let mut init_reader = init_expr.get_operators_reader();
-            if let wasmparser::Operator::I32Const { value: start_index } = init_reader.read()? {
-                start_index as u32
-            } else {
-                bail!("Table element start index is not a integer constant");
-            }
-        } else {
-            bail!("Unsupported table element kind");
-        };
-
-        let mut items_reader = element.items.get_items_reader()?;
-
-        let mut functions = Vec::with_capacity(items_reader.get_count() as usize);
-        for _ in 0..items_reader.get_count() {
-            if let wasmparser::ElementItem::Func(index) = items_reader.read()? {
-                functions.push(index);
-            } else {
-                bail!("Table element item is not a function");
+                let mut functions = Vec::with_capacity(funcs_reader.count() as usize);
+                for index in funcs_reader {
+                    functions.push(index?);
+                }
+
+                Ok(Element {
+                    start_index,
+                    functions,
+                })
            }
+            _ => bail!("Table element type is not FuncRef"),
        }
-
-        Ok(Element {
-            start_index,
-            functions,
-        })
    }
 }

@@ -707,8 +704,8 @@ fn read_export_section(reader: ExportSectionReader) -> Result<Vec<(String, u32)>
    for export in reader {
        let export = export?;
        match export.kind {
-            ExternalKind::Function => {
-                function_exports.push((export.field.to_string(), export.index));
+            ExternalKind::Func => {
+                function_exports.push((export.name.to_string(), export.index));
            }
            _ => (), // just ignore all other kinds since MicroW8 doesn't expect any exports other than functions
        }
@@ -729,13 +726,11 @@ fn remap_function(
    }
    let mut function = enc::Function::new(locals);

-    let block_type = |ty: wasmparser::TypeOrFuncType| -> Result<enc::BlockType> {
+    let block_type = |ty: wasmparser::BlockType| -> Result<enc::BlockType> {
        Ok(match ty {
-            wasmparser::TypeOrFuncType::Type(wasmparser::Type::EmptyBlockType) => {
-                enc::BlockType::Empty
-            }
-            wasmparser::TypeOrFuncType::Type(ty) => enc::BlockType::Result(to_val_type(&ty)?),
-            wasmparser::TypeOrFuncType::FuncType(ty) => enc::BlockType::FunctionType(
+            wasmparser::BlockType::Empty => enc::BlockType::Empty,
+            wasmparser::BlockType::Type(ty) => enc::BlockType::Result(to_val_type(&ty)?),
+            wasmparser::BlockType::FuncType(ty) => enc::BlockType::FunctionType(
                *type_map
                    .get(&ty)
                    .ok_or_else(|| anyhow!("Function type index out of range: {}", ty))?,
@@ -749,7 +744,7 @@ fn remap_function(
            .ok_or_else(|| anyhow!("Global index out of range: {}", idx))?)
    };

-    fn mem(m: wasmparser::MemoryImmediate) -> enc::MemArg {
+    fn mem(m: wasmparser::MemArg) -> enc::MemArg {
        enc::MemArg {
            offset: m.offset,
            align: m.align as u32,
@@ -764,24 +759,31 @@ fn remap_function(
        function.instruction(&match op? {
            De::Unreachable => En::Unreachable,
            De::Nop => En::Nop,
-            De::Block { ty } => En::Block(block_type(ty)?),
-            De::Loop { ty } => En::Loop(block_type(ty)?),
-            De::If { ty } => En::If(block_type(ty)?),
+            De::Block { blockty } => En::Block(block_type(blockty)?),
+            De::Loop { blockty } => En::Loop(block_type(blockty)?),
+            De::If { blockty } => En::If(block_type(blockty)?),
            De::Else => En::Else,
            De::Try { .. } | De::Catch { .. } | De::Throw { .. } | De::Rethrow { .. } => todo!(),
            De::End => En::End,
            De::Br { relative_depth } => En::Br(relative_depth),
            De::BrIf { relative_depth } => En::BrIf(relative_depth),
-            De::BrTable { .. } => todo!(),
+            De::BrTable { targets } => En::BrTable(
+                targets.targets().collect::<Result<Vec<u32>, _>>()?.into(),
+                targets.default(),
+            ),
            De::Return => En::Return,
            De::Call { function_index } => En::Call(
                *function_map
                    .get(&function_index)
                    .ok_or_else(|| anyhow!("Function index out of range: {}", function_index))?,
            ),
-            De::CallIndirect { index, table_index } => En::CallIndirect {
+            De::CallIndirect {
+                type_index,
+                table_index,
+                table_byte: _, // what is this supposed to be?
+            } => En::CallIndirect {
                ty: *type_map
-                    .get(&index)
+                    .get(&type_index)
                    .ok_or_else(|| anyhow!("Unknown function type in call indirect"))?,
                table: table_index,
            },
@@ -801,16 +803,16 @@ fn remap_function(
            De::I64Load { memarg } => En::I64Load(mem(memarg)),
            De::F32Load { memarg } => En::F32Load(mem(memarg)),
            De::F64Load { memarg } => En::F64Load(mem(memarg)),
-            De::I32Load8S { memarg } => En::I32Load8_S(mem(memarg)),
-            De::I32Load8U { memarg } => En::I32Load8_U(mem(memarg)),
-            De::I32Load16S { memarg } => En::I32Load16_S(mem(memarg)),
-            De::I32Load16U { memarg } => En::I32Load16_U(mem(memarg)),
-            De::I64Load8S { memarg } => En::I64Load8_S(mem(memarg)),
-            De::I64Load8U { memarg } => En::I64Load8_U(mem(memarg)),
-            De::I64Load16S { memarg } => En::I64Load16_S(mem(memarg)),
-            De::I64Load16U { memarg } => En::I64Load16_U(mem(memarg)),
-            De::I64Load32S { memarg } => En::I64Load32_S(mem(memarg)),
-            De::I64Load32U { memarg } => En::I64Load32_U(mem(memarg)),
+            De::I32Load8S { memarg } => En::I32Load8S(mem(memarg)),
+            De::I32Load8U { memarg } => En::I32Load8U(mem(memarg)),
+            De::I32Load16S { memarg } => En::I32Load16S(mem(memarg)),
+            De::I32Load16U { memarg } => En::I32Load16U(mem(memarg)),
+            De::I64Load8S { memarg } => En::I64Load8S(mem(memarg)),
+            De::I64Load8U { memarg } => En::I64Load8U(mem(memarg)),
+            De::I64Load16S { memarg } => En::I64Load16S(mem(memarg)),
+            De::I64Load16U { memarg } => En::I64Load16U(mem(memarg)),
+            De::I64Load32S { memarg } => En::I64Load32S(mem(memarg)),
+            De::I64Load32U { memarg } => En::I64Load32U(mem(memarg)),
            De::I32Store { memarg } => En::I32Store(mem(memarg)),
            De::I64Store { memarg } => En::I64Store(mem(memarg)),
            De::F32Store { memarg } => En::F32Store(mem(memarg)),
@@ -829,7 +831,7 @@ fn remap_function(
            De::RefNull { .. } | De::RefIsNull { .. } | De::RefFunc { .. } => todo!(),
            De::I32Eqz => En::I32Eqz,
            De::I32Eq => En::I32Eq,
-            De::I32Ne => En::I32Neq,
+            De::I32Ne => En::I32Ne,
            De::I32LtS => En::I32LtS,
            De::I32LtU => En::I32LtU,
            De::I32GtS => En::I32GtS,
@@ -840,7 +842,7 @@ fn remap_function(
            De::I32GeU => En::I32GeU,
            De::I64Eqz => En::I64Eqz,
            De::I64Eq => En::I64Eq,
-            De::I64Ne => En::I64Neq,
+            De::I64Ne => En::I64Ne,
            De::I64LtS => En::I64LtS,
            De::I64LtU => En::I64LtU,
            De::I64GtS => En::I64GtS,
@@ -850,13 +852,13 @@ fn remap_function(
            De::I64GeS => En::I64GeS,
            De::I64GeU => En::I64GeU,
            De::F32Eq => En::F32Eq,
-            De::F32Ne => En::F32Neq,
+            De::F32Ne => En::F32Ne,
            De::F32Lt => En::F32Lt,
            De::F32Gt => En::F32Gt,
            De::F32Le => En::F32Le,
            De::F32Ge => En::F32Ge,
            De::F64Eq => En::F64Eq,
-            De::F64Ne => En::F64Neq,
+            De::F64Ne => En::F64Ne,
            De::F64Lt => En::F64Lt,
            De::F64Gt => En::F64Gt,
            De::F64Le => En::F64Le,
@@ -963,7 +965,7 @@ fn remap_function(
            De::I64TruncSatF32U => En::I64TruncSatF32U,
            De::I64TruncSatF64S => En::I64TruncSatF64S,
            De::I64TruncSatF64U => En::I64TruncSatF64U,
-            De::MemoryCopy { src, dst } => En::MemoryCopy { src, dst },
+            De::MemoryCopy { src_mem, dst_mem } => En::MemoryCopy { src_mem, dst_mem },
            De::MemoryFill { mem } => En::MemoryFill(mem),
            other => bail!("Unsupported instruction {:?}", other),
        });
--- a/uw8-window/Cargo.lock
+++ b/uw8-window/Cargo.lock
--- a/uw8-window/Cargo.toml
+++ b/uw8-window/Cargo.toml
@@ -6,13 +6,13 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-winit = "0.26.1"
-env_logger = "0.9"
+winit = "0.29.15"
+env_logger = "0.11.3"
 log = "0.4"
-pico-args = "0.4"
-wgpu = "0.13.1"
-pollster = "0.2"
-bytemuck = { version = "1.4", features = [ "derive" ] }
+pico-args = "0.5"
+wgpu = "0.19.3"
+pollster = "0.3.0"
+bytemuck = { version = "1.15", features = [ "derive" ] }
 anyhow = "1"
-minifb = { version = "0.23.0", default-features = false, features = ["x11"] }
-winapi = "0.3.9"
+minifb = { version = "0.25.0", default-features = false, features = ["x11"] }
+winapi = { version = "0.3.9", features = [ "timeapi" ] }
--- a/uw8-window/src/gpu/crt.wgsl
+++ b/uw8-window/src/gpu/crt.wgsl
@@ -36,36 +36,36 @@ fn sample_pixel(coords: vec2<i32>, offset: vec4<f32>) -> vec3<f32> {

@fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    let pixel = floor(in.tex_coords);
-    let o = vec2<f32>(0.5) - (in.tex_coords - pixel);
-    let pixel = vec2<i32>(pixel);
+    let pixelf = floor(in.tex_coords);
+    let o = vec2<f32>(0.5) - (in.tex_coords - pixelf);
+    let pixel = vec2<i32>(pixelf);
    
    let offset_x = o.xxxx + vec4<f32>(-0.125, 0.375, 0.125, -0.375) * uniforms.texture_scale.z;
    let offset_y = o.yyyy + vec4<f32>(-0.375, -0.125, 0.375, 0.125) * uniforms.texture_scale.z;
    
-    let offset_x0 = max(abs(offset_x + vec4<f32>(-1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
-    let offset_x1 = max(abs(offset_x) - vec4<f32>(0.5), vec4<f32>(0.0));
-    let offset_x2 = max(abs(offset_x + vec4<f32>(1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
+    var offset_x0 = max(abs(offset_x + vec4<f32>(-1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
+    var offset_x1 = max(abs(offset_x) - vec4<f32>(0.5), vec4<f32>(0.0));
+    var offset_x2 = max(abs(offset_x + vec4<f32>(1.0)) - vec4<f32>(0.5), vec4<f32>(0.0));
    
-    let offset_x0 = offset_x0 * offset_x0;
-    let offset_x1 = offset_x1 * offset_x1;
-    let offset_x2 = offset_x2 * offset_x2;
+    offset_x0 = offset_x0 * offset_x0;
+    offset_x1 = offset_x1 * offset_x1;
+    offset_x2 = offset_x2 * offset_x2;
    
-    let offset_yr = offset_y + vec4<f32>(-1.0);
-    let offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
+    var offset_yr = offset_y + vec4<f32>(-1.0);
+    offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
    
    var acc = sample_pixel(pixel + vec2<i32>(-1, -1), offset_x0 + offset_yr);
    acc = acc + sample_pixel(pixel + vec2<i32>(0, -1), offset_x1 + offset_yr);
    acc = acc + sample_pixel(pixel + vec2<i32>(1, -1), offset_x2 + offset_yr);

-    let offset_yr = vec4<f32>(0.02) + offset_y * offset_y;
+    offset_yr = vec4<f32>(0.02) + offset_y * offset_y;
    
    acc = acc + sample_pixel(pixel + vec2<i32>(-1, 0), offset_x0 + offset_yr);
    acc = acc + sample_pixel(pixel, offset_x1 + offset_yr);
    acc = acc + sample_pixel(pixel + vec2<i32>(1, 0), offset_x2 + offset_yr);

-    let offset_yr = offset_y + vec4<f32>(1.0);
-    let offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
+    offset_yr = offset_y + vec4<f32>(1.0);
+    offset_yr = vec4<f32>(0.02) + offset_yr * offset_yr;
    
    acc = acc + sample_pixel(pixel + vec2<i32>(-1, 1), offset_x0 + offset_yr);
    acc = acc + sample_pixel(pixel + vec2<i32>(0, 1), offset_x1 + offset_yr);
--- a/uw8-window/src/gpu/fast_crt.wgsl
+++ b/uw8-window/src/gpu/fast_crt.wgsl
@@ -30,8 +30,8 @@ fn row_factor(offset: f32) -> f32 {
 }

 fn col_factor(offset: f32) -> f32 {
-    let offset = max(0.0, abs(offset) - 0.4);
-    return 1.0 / (1.0 + offset * offset * 16.0);
+    let o = max(0.0, abs(offset) - 0.4);
+    return 1.0 / (1.0 + o * o * 16.0);
 }

 fn sample_screen(tex_coords: vec2<f32>) -> vec4<f32> {
--- a/uw8-window/src/gpu/mod.rs
+++ b/uw8-window/src/gpu/mod.rs
@@ -1,16 +1,16 @@
 use crate::{Input, WindowConfig, WindowImpl};
 use anyhow::{anyhow, Result};
-use std::{num::NonZeroU32, time::Instant};
+use std::{sync::Arc, time::Instant};

 use winit::{
    dpi::PhysicalSize,
-    event::{Event, VirtualKeyCode, WindowEvent},
+    event::{Event, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
+    keyboard::{Key, KeyCode, NamedKey, PhysicalKey},
+    platform::pump_events::{EventLoopExtPumpEvents, PumpStatus},
    window::{Fullscreen, WindowBuilder},
 };

-use winit::platform::run_return::EventLoopExtRunReturn;
-
 mod crt;
 mod fast_crt;
 mod square;
@@ -21,7 +21,7 @@ use square::SquareFilter;

 pub struct Window {
    _instance: wgpu::Instance,
-    surface: wgpu::Surface,
+    surface: wgpu::Surface<'static>,
    _adapter: wgpu::Adapter,
    device: wgpu::Device,
    queue: wgpu::Queue,
@@ -29,7 +29,7 @@ pub struct Window {
    surface_config: wgpu::SurfaceConfiguration,
    filter: Box<dyn Filter>,
    event_loop: EventLoop<()>,
-    window: winit::window::Window,
+    window: Arc<winit::window::Window>,
    gamepads: [u8; 4],
    next_frame: Instant,
    is_fullscreen: bool,
@@ -39,9 +39,12 @@ pub struct Window {
 impl Window {
    pub fn new(window_config: WindowConfig) -> Result<Window> {
        async fn create(window_config: WindowConfig) -> Result<Window> {
-            let event_loop = EventLoop::new();
+            let event_loop = EventLoop::new()?;
            let window = WindowBuilder::new()
-                .with_inner_size(PhysicalSize::new(640u32, 480))
+                .with_inner_size(PhysicalSize::new(
+                    (320. * window_config.scale).round() as u32,
+                    (240. * window_config.scale).round() as u32,
+                ))
                .with_min_inner_size(PhysicalSize::new(320u32, 240))
                .with_title("MicroW8")
                .with_fullscreen(if window_config.fullscreen {
@@ -53,8 +56,10 @@ impl Window {

            window.set_cursor_visible(false);

-            let instance = wgpu::Instance::new(wgpu::Backends::all());
-            let surface = unsafe { instance.create_surface(&window) };
+            let window = Arc::new(window);
+
+            let instance = wgpu::Instance::new(Default::default());
+            let surface = instance.create_surface(window.clone())?;
            let adapter = instance
                .request_adapter(&wgpu::RequestAdapterOptions {
                    power_preference: wgpu::PowerPreference::LowPower,
@@ -71,11 +76,14 @@ impl Window {
            let palette_screen_mode = PaletteScreenMode::new(&device);

            let surface_config = wgpu::SurfaceConfiguration {
-                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-                format: surface.get_supported_formats(&adapter)[0],
-                width: window.inner_size().width,
-                height: window.inner_size().height,
                present_mode: wgpu::PresentMode::AutoNoVsync,
+                ..surface
+                    .get_default_config(
+                        &adapter,
+                        window.inner_size().width,
+                        window.inner_size().height,
+                    )
+                    .expect("Surface incompatible with adapter")
            };

            let filter: Box<dyn Filter> = create_filter(
@@ -113,88 +121,93 @@ impl Window {
 impl WindowImpl for Window {
    fn begin_frame(&mut self) -> Input {
        let mut reset = false;
-        self.event_loop.run_return(|event, _, control_flow| {
-            *control_flow = ControlFlow::WaitUntil(self.next_frame);
-            let mut new_filter = None;
-            match event {
-                Event::WindowEvent { event, .. } => match event {
-                    WindowEvent::Resized(new_size) => {
-                        self.surface_config.width = new_size.width;
-                        self.surface_config.height = new_size.height;
-                        self.surface.configure(&self.device, &self.surface_config);
-                        self.filter.resize(&self.queue, new_size);
-                    }
-                    WindowEvent::CloseRequested => {
-                        self.is_open = false;
-                        *control_flow = ControlFlow::Exit;
-                    }
-                    WindowEvent::KeyboardInput { input, .. } => {
-                        fn gamepad_button(input: &winit::event::KeyboardInput) -> u8 {
-                            match input.scancode {
-                                44 => 16,
-                                45 => 32,
-                                30 => 64,
-                                31 => 128,
-                                _ => match input.virtual_keycode {
-                                    Some(VirtualKeyCode::Up) => 1,
-                                    Some(VirtualKeyCode::Down) => 2,
-                                    Some(VirtualKeyCode::Left) => 4,
-                                    Some(VirtualKeyCode::Right) => 8,
-                                    _ => 0,
-                                },
-                            }
+        self.event_loop
+            .set_control_flow(ControlFlow::WaitUntil(self.next_frame));
+        while self.is_open {
+            let timeout = self.next_frame.saturating_duration_since(Instant::now());
+            let status = self.event_loop.pump_events(Some(timeout), |event, elwt| {
+                let mut new_filter = None;
+                match event {
+                    Event::WindowEvent { event, .. } => match event {
+                        WindowEvent::Resized(new_size) => {
+                            self.surface_config.width = new_size.width;
+                            self.surface_config.height = new_size.height;
+                            self.surface.configure(&self.device, &self.surface_config);
+                            self.filter.resize(&self.queue, new_size);
                        }
-                        if input.state == winit::event::ElementState::Pressed {
-                            match input.virtual_keycode {
-                                Some(VirtualKeyCode::Escape) => {
-                                    self.is_open = false;
-                                    *control_flow = ControlFlow::Exit;
+                        WindowEvent::CloseRequested => {
+                            elwt.exit();
+                        }
+                        WindowEvent::KeyboardInput { event, .. } => {
+                            fn gamepad_button(input: &winit::event::KeyEvent) -> u8 {
+                                match input.physical_key {
+                                    PhysicalKey::Code(KeyCode::KeyZ) => 16,
+                                    PhysicalKey::Code(KeyCode::KeyX) => 32,
+                                    PhysicalKey::Code(KeyCode::KeyA) => 64,
+                                    PhysicalKey::Code(KeyCode::KeyS) => 128,
+                                    _ => match input.logical_key {
+                                        Key::Named(NamedKey::ArrowUp) => 1,
+                                        Key::Named(NamedKey::ArrowDown) => 2,
+                                        Key::Named(NamedKey::ArrowLeft) => 4,
+                                        Key::Named(NamedKey::ArrowRight) => 8,
+                                        _ => 0,
+                                    },
                                }
-                                Some(VirtualKeyCode::F) => {
-                                    let fullscreen = if self.window.fullscreen().is_some() {
-                                        None
-                                    } else {
-                                        Some(Fullscreen::Borderless(None))
-                                    };
-                                    self.is_fullscreen = fullscreen.is_some();
-                                    self.window.set_fullscreen(fullscreen);
-                                }
-                                Some(VirtualKeyCode::R) => reset = true,
-                                Some(VirtualKeyCode::Key1) => new_filter = Some(1),
-                                Some(VirtualKeyCode::Key2) => new_filter = Some(2),
-                                Some(VirtualKeyCode::Key3) => new_filter = Some(3),
-                                Some(VirtualKeyCode::Key4) => new_filter = Some(4),
-                                Some(VirtualKeyCode::Key5) => new_filter = Some(5),
-                                _ => (),
                            }
+                            if event.state == winit::event::ElementState::Pressed {
+                                match event.logical_key {
+                                    Key::Named(NamedKey::Escape) => {
+                                        elwt.exit();
+                                    }
+                                    Key::Character(ref c) => match c.as_str() {
+                                        "f" => {
+                                            let fullscreen = if self.window.fullscreen().is_some() {
+                                                None
+                                            } else {
+                                                Some(Fullscreen::Borderless(None))
+                                            };
+                                            self.is_fullscreen = fullscreen.is_some();
+                                            self.window.set_fullscreen(fullscreen);
+                                        }
+                                        "r" => reset = true,
+                                        "1" => new_filter = Some(1),
+                                        "2" => new_filter = Some(2),
+                                        "3" => new_filter = Some(3),
+                                        "4" => new_filter = Some(4),
+                                        "5" => new_filter = Some(5),
+                                        _ => (),
+                                    },
+                                    _ => (),
+                                }

-                            self.gamepads[0] |= gamepad_button(&input);
-                        } else {
-                            self.gamepads[0] &= !gamepad_button(&input);
+                                self.gamepads[0] |= gamepad_button(&event);
+                            } else {
+                                self.gamepads[0] &= !gamepad_button(&event);
+                            }
                        }
-                    }
+                        _ => (),
+                    },
                    _ => (),
-                },
-                Event::RedrawEventsCleared => {
-                    if Instant::now() >= self.next_frame
-                        // workaround needed on Wayland until the next winit release
-                        && self.window.fullscreen().is_some() == self.is_fullscreen
-                    {
-                        *control_flow = ControlFlow::Exit
-                    }
                }
+                if let Some(new_filter) = new_filter {
+                    self.filter = create_filter(
+                        &self.device,
+                        &self.palette_screen_mode.screen_view,
+                        self.window.inner_size(),
+                        self.surface_config.format,
+                        new_filter,
+                    );
+                }
+            });
+            match status {
+                PumpStatus::Exit(_) => self.is_open = false,
                _ => (),
            }
-            if let Some(new_filter) = new_filter {
-                self.filter = create_filter(
-                    &self.device,
-                    &self.palette_screen_mode.screen_view,
-                    self.window.inner_size(),
-                    self.surface_config.format,
-                    new_filter,
-                );
+
+            if Instant::now() >= self.next_frame {
+                break;
            }
-        });
+        }
        Input {
            gamepads: self.gamepads,
            reset,
@@ -230,10 +243,12 @@ impl WindowImpl for Window {
                            b: 0.0,
                            a: 1.0,
                        }),
-                        store: true,
+                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
            });

            self.filter.render(&mut render_pass);
@@ -357,6 +372,7 @@ impl PaletteScreenMode {
            format: wgpu::TextureFormat::R8Uint,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
            label: None,
+            view_formats: &[],
        });

        let palette_texture = device.create_texture(&wgpu::TextureDescriptor {
@@ -371,6 +387,7 @@ impl PaletteScreenMode {
            format: wgpu::TextureFormat::Rgba8UnormSrgb,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
            label: None,
+            view_formats: &[],
        });

        let screen_texture = device.create_texture(&wgpu::TextureDescriptor {
@@ -385,6 +402,7 @@ impl PaletteScreenMode {
            format: wgpu::TextureFormat::Rgba8UnormSrgb,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
            label: None,
+            view_formats: &[],
        });

        let framebuffer_texture_view =
@@ -491,7 +509,7 @@ impl PaletteScreenMode {
            &bytemuck::cast_slice(pixels),
            wgpu::ImageDataLayout {
                offset: 0,
-                bytes_per_row: NonZeroU32::new(320),
+                bytes_per_row: Some(320),
                rows_per_image: None,
            },
            wgpu::Extent3d {
@@ -513,7 +531,7 @@ impl PaletteScreenMode {
            &bytemuck::cast_slice(palette),
            wgpu::ImageDataLayout {
                offset: 0,
-                bytes_per_row: NonZeroU32::new(256 * 4),
+                bytes_per_row: Some(256 * 4),
                rows_per_image: None,
            },
            wgpu::Extent3d {
@@ -532,10 +550,12 @@ impl PaletteScreenMode {
                resolve_target: None,
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Load,
-                    store: true,
+                    store: wgpu::StoreOp::Store,
                },
            })],
            depth_stencil_attachment: None,
+            timestamp_writes: None,
+            occlusion_query_set: None,
        });

        render_pass.set_pipeline(&self.pipeline);
--- a/uw8-window/src/lib.rs
+++ b/uw8-window/src/lib.rs
@@ -4,31 +4,65 @@ use std::time::Instant;
 mod cpu;
 mod gpu;

-pub struct Window(Box<dyn WindowImpl>);
+pub struct Window {
+    inner: Box<dyn WindowImpl>,
+    fps_counter: Option<FpsCounter>,
+}
+
+struct FpsCounter {
+    start: Instant,
+    num_frames: u32,
+}

 impl Window {
-    pub fn new(config: WindowConfig) -> Result<Window> {
+    pub fn new(mut config: WindowConfig) -> Result<Window> {
+        let fps_counter = if config.fps_counter {
+            Some(FpsCounter {
+                start: Instant::now(),
+                num_frames: 0,
+            })
+        } else {
+            None
+        };
+        config.scale = config.scale.max(1.).min(20.);
        if config.enable_gpu {
            match gpu::Window::new(config) {
-                Ok(window) => return Ok(Window(Box::new(window))),
+                Ok(window) => {
+                    return Ok(Window {
+                        inner: Box::new(window),
+                        fps_counter,
+                    })
+                }
                Err(err) => eprintln!(
                    "Failed to create gpu window: {}\nFalling back tp cpu window",
                    err
                ),
            }
        }
-        cpu::Window::new().map(|window| Window(Box::new(window)))
+        cpu::Window::new().map(|window| Window {
+            inner: Box::new(window),
+            fps_counter,
+        })
    }

    pub fn begin_frame(&mut self) -> Input {
-        self.0.begin_frame()
+        self.inner.begin_frame()
    }
    pub fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
-        self.0.end_frame(framebuffer, palette, next_frame)
+        self.inner.end_frame(framebuffer, palette, next_frame);
+        if let Some(ref mut fps_counter) = self.fps_counter {
+            fps_counter.num_frames += 1;
+            let elapsed = fps_counter.start.elapsed().as_secs_f32();
+            if elapsed >= 1.0 {
+                println!("fps: {:.1}", fps_counter.num_frames as f32 / elapsed);
+                fps_counter.num_frames = 0;
+                fps_counter.start = Instant::now();
+            }
+        }
    }

    pub fn is_open(&self) -> bool {
-        self.0.is_open()
+        self.inner.is_open()
    }
 }

@@ -37,6 +71,8 @@ pub struct WindowConfig {
    enable_gpu: bool,
    filter: u32,
    fullscreen: bool,
+    fps_counter: bool,
+    scale: f32,
 }

 impl Default for WindowConfig {
@@ -45,6 +81,8 @@ impl Default for WindowConfig {
            enable_gpu: true,
            filter: 5,
            fullscreen: false,
+            fps_counter: false,
+            scale: 2.,
        }
    }
 }
@@ -66,6 +104,11 @@ impl WindowConfig {
            }
        }
        self.fullscreen = args.contains("--fullscreen");
+        self.fps_counter = args.contains("--fps");
+        self.scale = args
+            .opt_value_from_str("--scale")
+            .unwrap()
+            .unwrap_or(self.scale);
    }
 }

--- a/web/src/audiolet.js
+++ b/web/src/audiolet.js
@@ -63,7 +63,7 @@ class APU extends AudioWorkletProcessor {

        this.memory = memory;

-        this.snd = instance.exports.snd || platform_instance.exports.gesSnd;
+        this.snd = instance.exports.snd || platform_instance.exports.sndGes;

        this.port.postMessage(2);
    }
--- a/web/src/index.html
+++ b/web/src/index.html
@@ -10,7 +10,7 @@
    </head>
    <body>
        <div id="uw8">
-            <a href="https://exoticorn.github.io/microw8">MicroW8</a> 0.2.1
+            <a href="https://exoticorn.github.io/microw8">MicroW8</a> 0.2.2
        </div>
        <div id="centered">
            <canvas class="screen" id="screen" width="320" height="240">
--- a/web/src/microw8.js
+++ b/web/src/microw8.js
@@ -263,6 +263,10 @@ export default function MicroW8(screen, config = {}) {
            window.addEventListener('blur', () => updateVisibility(false), { signal: abortController.signal });
            updateVisibility(document.hasFocus());

+            if (instance.exports.start) {
+                instance.exports.start();
+            }
+
            function mainloop() {
                if (!keepRunning) {
                    return;
Author	SHA1	Message	Date
Dennis Ranke	4e18d38538	add untested implementation of text scale	2024-04-07 23:59:14 +02:00
Dennis Ranke	d4bad3ba8b	add sprite flipping to example	2024-04-07 23:20:13 +02:00
Dennis Ranke	6ddda24156	Merge branch 'sprites'	2024-04-07 22:58:26 +02:00
Dennis Ranke	7003db3a05	update dependencies	2024-04-03 10:26:41 +02:00
Dennis Ranke	8258bc1854	fix typo	2023-09-13 07:36:24 +02:00
Dennis Ranke	a651107104	add start and snd functions to filter exports exclude list	2023-09-03 10:19:30 +02:00
Dennis Ranke	22c35e37f4	remove debug trace	2023-09-02 15:37:27 +02:00
Dennis Ranke	805c939097	add support for sound devices that only accept 16bit audio	2023-08-23 23:03:23 +02:00
Dennis Ranke	440e150896	update dependencies	2023-08-23 00:52:51 +02:00
Dennis Ranke	77b2e27346	clamp snd samples into valid -1.0..1.0 range	2023-08-23 00:20:35 +02:00
Dennis Ranke	09e4fcbf14	add --scale option	2023-08-11 23:52:19 +02:00
Dennis Ranke	c8a9f533ef	copy optimized blitSprite impl to grabSprite, add simple docs	2023-04-03 23:44:12 +02:00
Dennis Ranke	4a1d607bcb	optimize blitSprite	2023-04-03 00:09:02 +02:00
Dennis Ranke	bbb75838cd	first unoptimized version of blitSprite & grabSprite	2023-04-02 23:21:31 +02:00
Dennis Ranke	dbeb242fb2	add support for br_table instruction when packing cart	2023-03-20 23:08:42 +01:00
Dennis Ranke	4fe4bce0ad	token env var has changed	2023-01-31 00:14:25 +01:00
Dennis Ranke	fe86153562	use fixed version of zola-deploy-action	2023-01-31 00:01:07 +01:00
Dennis Ranke	c9dadaca2e	try add safe.directory	2023-01-30 09:48:57 +01:00
Dennis Ranke	5dc3e281ce	and again	2023-01-30 09:45:28 +01:00
Dennis Ranke	ce3afb821f	another attempt changing the owner to fix permission issue	2023-01-30 09:43:54 +01:00
Dennis Ranke	2652a351ad	remove chown again	2023-01-30 09:38:57 +01:00
Dennis Ranke	9109722409	fix main.yml	2023-01-30 09:37:12 +01:00
Dennis Ranke	f861c262a1	update ci actions, hopefully fix permission error	2023-01-30 09:15:09 +01:00
Dennis Ranke	bbfb5eba49	add back event debouncing in file watcher	2023-01-30 00:09:25 +01:00
Dennis Ranke	9e19ff1761	prepare for 0.2.2 release	2023-01-28 12:47:16 +01:00
Dennis Ranke	5d85aeac09	call an exported start function if it exists	2023-01-28 12:31:16 +01:00
Dennis Ranke	30eb953d5d	remove test code that was accidentally committed	2023-01-28 11:37:05 +01:00
Dennis Ranke	abdf780533	only open browser once cart has been compiled succesfully	2023-01-28 11:33:49 +01:00
Dennis Ranke	fc05a54e2c	fix control codes 4-6 as parameters to other control codes	2023-01-28 10:58:28 +01:00
Dennis Ranke	b33099c828	update more dependencies	2023-01-28 02:11:25 +01:00
Dennis Ranke	d478d3ad49	enable timeapi in winapi crate	2023-01-27 00:13:32 +01:00
Dennis Ranke	502852e59a	update uw8-window dependencies	2023-01-26 23:40:54 +01:00
Dennis Ranke	5efa8b3465	first batch of dependency updates	2023-01-26 22:45:34 +01:00
Dennis Ranke	daf2a02cd8	fix sndGes name & add missing auto-import	2023-01-23 23:21:45 +01:00
Dennis Ranke	8d5374a867	add support to ignore empty memory section when packing	2022-11-03 23:27:53 +01:00
Dennis Ranke	142b6a4c15	fix typo in sample rate selection	2022-10-30 00:07:58 +02:00
Dennis Ranke	877fceb089	add --fps parameter to output fps	2022-07-25 23:44:06 +02:00
Dennis Ranke	f0ba0f2b99	update site with 0.2.1 release	2022-07-25 08:46:23 +02:00
				`@@ -0,0 +1 @@`
				`* add support for 16bit sound (not just float)`