clamp snd samples into valid -1.0..1.0 range

call an exported start function if it exists
only open browser once cart has been compiled succesfully
2026-01-20 11:16:42 +01:00 · 2024-06-09 00:46:16 +02:00 · 2024-06-09 00:35:25 +02:00 · 2024-06-09 00:35:13 +02:00 · 2024-06-09 00:33:49 +02:00 · 2023-01-23 23:21:45 +01:00
35 changed files with 906 additions and 350 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -159,6 +159,12 @@ dependencies = [
 "rustc-demangle",
 ]

+[[package]]
+name = "base-x"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270"
+
 [[package]]
 name = "base64"
 version = "0.13.0"
@@ -559,27 +565,27 @@ dependencies = [

 [[package]]
 name = "cpal"
-version = "0.13.5"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74117836a5124f3629e4b474eed03e479abaf98988b4bb317e29f08cfe0e4116"
+checksum = "e73413ddcb69c398125f5529714492e070c64c6a090ad5b01d8c082b320a0809"
 dependencies = [
 "alsa",
 "core-foundation-sys 0.8.3",
 "coreaudio-rs",
 "jni",
 "js-sys",
- "lazy_static",
 "libc",
 "mach",
- "ndk 0.6.0",
- "ndk-glue 0.6.1",
- "nix 0.23.1",
+ "ndk 0.7.0",
+ "ndk-context",
+ "nix 0.25.0",
 "oboe",
- "parking_lot",
+ "once_cell",
+ "parking_lot 0.12.1",
 "stdweb",
 "thiserror",
 "web-sys",
- "winapi 0.3.9",
+ "windows",
 ]

 [[package]]
@@ -863,6 +869,12 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "discard"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "212d0f5754cb6769937f4501cc0e67f4f4483c8d2c3e1e922ee9edbe4ab4c7c0"
+
 [[package]]
 name = "dispatch"
 version = "0.2.0"
@@ -1588,9 +1600,9 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"

 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"

 [[package]]
 name = "libloading"
@@ -1885,6 +1897,20 @@ dependencies = [
 "thiserror",
 ]

+[[package]]
+name = "ndk"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "451422b7e4718271c8b5b3aadf5adedba43dc76312454b387e98fae0fc951aa0"
+dependencies = [
+ "bitflags",
+ "jni-sys",
+ "ndk-sys 0.4.0",
+ "num_enum",
+ "raw-window-handle 0.5.0",
+ "thiserror",
+]
+
 [[package]]
 name = "ndk-context"
 version = "0.1.0"
@@ -1949,6 +1975,15 @@ dependencies = [
 "jni-sys",
 ]

+[[package]]
+name = "ndk-sys"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21d83ec9c63ec5bf950200a8e508bdad6659972187b625469f58ef8c08e29046"
+dependencies = [
+ "jni-sys",
+]
+
 [[package]]
 name = "net2"
 version = "0.2.37"
@@ -1986,6 +2021,20 @@ dependencies = [
 "memoffset",
 ]

+[[package]]
+name = "nix"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e322c04a9e3440c327fca7b6c8a63e6890a32fa2ad689db972425f07e0d22abb"
+dependencies = [
+ "autocfg",
+ "bitflags",
+ "cfg-if 1.0.0",
+ "libc",
+ "memoffset",
+ "pin-utils",
+]
+
 [[package]]
 name = "nom"
 version = "7.1.1"
@@ -2158,9 +2207,9 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.9.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"

 [[package]]
 name = "opaque-debug"
@@ -2191,7 +2240,17 @@ checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
 dependencies = [
 "instant",
 "lock_api",
- "parking_lot_core",
+ "parking_lot_core 0.8.5",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api",
+ "parking_lot_core 0.9.4",
 ]

 [[package]]
@@ -2208,6 +2267,19 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "parking_lot_core"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dc9e0dc2adc1c69d09143aff38d3d30c5c3f0df0dad82e6d25547af174ebec0"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-sys",
+]
+
 [[package]]
 name = "paste"
 version = "1.0.6"
@@ -2423,6 +2495,15 @@ dependencies = [
 "cty",
 ]

+[[package]]
+name = "raw-window-handle"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed7e3d950b66e19e0c372f3fa3fbbcf85b1746b571f74e0c2af6042a5c93420a"
+dependencies = [
+ "cty",
+]
+
 [[package]]
 name = "rayon"
 version = "1.5.1"
@@ -2556,6 +2637,15 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"

+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustfft"
 version = "6.0.1"
@@ -2654,6 +2744,21 @@ dependencies = [
 "version-compare",
 ]

+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+
 [[package]]
 name = "serde"
 version = "1.0.138"
@@ -2721,6 +2826,21 @@ dependencies = [
 "digest 0.10.3",
 ]

+[[package]]
+name = "sha1"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1da05c97445caa12d05e848c4a4fcbbea29e748ac28f7e80e9b010392063770"
+dependencies = [
+ "sha1_smol",
+]
+
+[[package]]
+name = "sha1_smol"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012"
+
 [[package]]
 name = "sha2"
 version = "0.9.9"
@@ -2814,9 +2934,52 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"

 [[package]]
 name = "stdweb"
-version = "0.1.3"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef5430c8e36b713e13b48a9f709cc21e046723fe44ce34587b73a830203b533e"
+checksum = "d022496b16281348b52d0e30ae99e01a73d737b2f45d38fed4edf79f9325a1d5"
+dependencies = [
+ "discard",
+ "rustc_version",
+ "stdweb-derive",
+ "stdweb-internal-macros",
+ "stdweb-internal-runtime",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "stdweb-derive"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c87a60a40fccc84bef0652345bbbbbe20a605bf5d0ce81719fc476f5c03b50ef"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_derive",
+ "syn",
+]
+
+[[package]]
+name = "stdweb-internal-macros"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58fa5ff6ad0d98d1ffa8cb115892b6e69d67799f6763e162a1c9db421dc22e11"
+dependencies = [
+ "base-x",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "sha1",
+ "syn",
+]
+
+[[package]]
+name = "stdweb-internal-runtime"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "213701ba3370744dcd1a12960caa4843b3d68b4d1c0a5d575e0d65b2ee9d16c0"

 [[package]]
 name = "strength_reduce"
@@ -3165,12 +3328,14 @@ checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"

 [[package]]
 name = "uw8"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
 "ansi_term",
 "anyhow",
 "cpal",
 "curlywas",
+ "env_logger 0.9.0",
+ "log",
 "notify",
 "pico-args",
 "rubato",
@@ -3207,6 +3372,7 @@ dependencies = [
 "env_logger 0.9.0",
 "log",
 "minifb",
+ "pico-args",
 "pollster",
 "wgpu",
 "winapi 0.3.9",
@@ -3740,7 +3906,7 @@ dependencies = [
 "js-sys",
 "log",
 "naga",
- "parking_lot",
+ "parking_lot 0.11.2",
 "raw-window-handle 0.4.2",
 "smallvec",
 "wasm-bindgen",
@@ -3766,7 +3932,7 @@ dependencies = [
 "fxhash",
 "log",
 "naga",
- "parking_lot",
+ "parking_lot 0.11.2",
 "profiling",
 "raw-window-handle 0.4.2",
 "smallvec",
@@ -3803,7 +3969,7 @@ dependencies = [
 "metal",
 "naga",
 "objc",
- "parking_lot",
+ "parking_lot 0.11.2",
 "profiling",
 "range-alloc",
 "raw-window-handle 0.4.2",
@@ -3873,6 +4039,106 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

+[[package]]
+name = "windows"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57b543186b344cc61c85b5aab0d2e3adf4e0f99bc076eff9aa5927bcc0b8a647"
+dependencies = [
+ "windows_aarch64_msvc 0.37.0",
+ "windows_i686_gnu 0.37.0",
+ "windows_i686_msvc 0.37.0",
+ "windows_x86_64_gnu 0.37.0",
+ "windows_x86_64_msvc 0.37.0",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc 0.42.0",
+ "windows_i686_gnu 0.42.0",
+ "windows_i686_msvc 0.42.0",
+ "windows_x86_64_gnu 0.42.0",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc 0.42.0",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2623277cb2d1c216ba3b578c0f3cf9cdebeddb6e66b1b218bb33596ea7769c3a"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3925fd0b0b804730d44d4b6278c50f9699703ec49bcd628020f46f4ba07d9e1"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce907ac74fe331b524c1298683efbf598bb031bc84d5e274db2083696d07c57c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2babfba0828f2e6b32457d5341427dcbb577ceef556273229959ac23a10af33d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4dd6dc7df2d84cf7b33822ed5b86318fb1781948e9663bacd047fc9dd52259d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"
+
 [[package]]
 name = "winit"
 version = "0.26.1"
@@ -3894,7 +4160,7 @@ dependencies = [
 "ndk-glue 0.5.1",
 "ndk-sys 0.2.2",
 "objc",
- "parking_lot",
+ "parking_lot 0.11.2",
 "percent-encoding",
 "raw-window-handle 0.4.2",
 "smithay-client-toolkit",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,8 @@ browser = ["warp", "tokio", "tokio-stream", "webbrowser"]
 [dependencies]
 wasmtime = { version = "0.37.0", optional = true }
 anyhow = "1"
+env_logger = "0.9"
+log = "0.4"
 uw8-window = { path = "uw8-window", optional = true }
 notify = "4"
 pico-args = "0.4"
@@ -25,5 +27,5 @@ 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 }
 ansi_term = "0.12.1"
-cpal = { version = "0.13.5", optional = true }
+cpal = { version = "0.14.1", optional = true }
 rubato = { version = "0.11.0", optional = true }
--- a/README.md
+++ b/README.md
@@ -43,6 +43,27 @@ Options:
 -l LEVEL, --level LEVEL : Compression level (0-9). Higher compression levels are really slow.
 -o FILE, --output FILE  : Write the loaded and optionally packed cart back to disk.

+when using the native runtime:
+
+-m, --no-audio          : Disable audio, also reduces cpu load a bit
+--no-gpu                : Force old cpu-only window code
+--filter FILTER         : Select an upscale filter at startup
+--fullscreen            : Start in fullscreen mode
+
+Note that the cpu-only window does not support fullscreen nor upscale filters.
+
+Unless --no-gpu is given, uw8 will first try to open a gpu accelerated window, falling back to the old cpu-only window if that fails.
+Therefore you should rarely need to manually pass --no-gpu. If you prefer the old pixel doubling look to the now default crt filter,
+you can just pass "--filter nearest" or "--filter 1".
+
+The upscale filter options are:
+1, nearest              : Anti-aliased nearest filter
+2, fast_crt             : Very simple, cheap crt filter, not very good below a window size of 960x720
+3, ss_crt               : Super sampled crt filter, a little more demanding on the GPU but scales well to smaller window sizes
+4, chromatic_crt        : Variant of fast_crt with a slight offset of the three color dots of a pixel, still pretty cheap
+5, auto_crt (default)   : ss_crt below 960x720, chromatic_crt otherwise
+
+You can switch the upscale filter at any time using the keys 1-5. You can toggle fullscreen with F.

 uw8 pack [<options>] <infile> <outfile>

--- a/examples/include/microw8-api.cwa
+++ b/examples/include/microw8-api.cwa
@@ -34,6 +34,7 @@ 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.exp" fn exp(f32) -> f32;
 import "env.playNote" fn playNote(i32, i32);
+import "env.sndGes" fn sndGes(i32) -> f32;

 const TIME_MS = 0x40;
 const GAMEPAD = 0x44;
--- a/examples/include/microw8-api.wat
+++ b/examples/include/microw8-api.wat
@@ -34,6 +34,7 @@
 (import "env" "circle_outline" (func $circle_outline (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)))

 ;; to use defines, include this file with a preprocessor
 ;; like gpp (https://logological.org/gpp).
--- a/platform/Cargo.lock
+++ b/platform/Cargo.lock
@@ -391,7 +391,7 @@ checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
 [[package]]
 name = "upkr"
 version = "0.1.0"
-source = "git+https://github.com/exoticorn/upkr.git?rev=2e7983fc#2e7983fc650788d98da2eecef2d16f63e849e4a0"
+source = "git+https://github.com/exoticorn/upkr.git?rev=d93aec186c9fb91d962c488682a2db125c61306c#d93aec186c9fb91d962c488682a2db125c61306c"
 dependencies = [
 "anyhow",
 "cdivsufsort",
--- 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
@@ -372,16 +372,7 @@ 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;
-    }
-
-    if outputChannel >= 2 {
+    if outputChannel >= 2 & (char < 4 | char > 6) {
        logChar(char);
        return;
    }
@@ -399,6 +390,15 @@ 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;
--- a/site/content/_index.md
+++ b/site/content/_index.md
@@ -29,6 +29,19 @@ Examplers for older versions:

 ## Versions

+### 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
@@ -436,6 +436,30 @@ and execution of the cart is stopped. Defaults to 30 (0.5s)
 * `-l LEVEL`, `--level LEVEL`: Compression level (0-9). Higher compression levels are really slow.
 * `-o FILE`, `--output FILE`: Write the loaded and optionally packed cart back to disk.

+when using the native runtime:
+
+* `-m`, `--no-audio`: Disable audio, also reduces cpu load a bit
+* `--no-gpu`:  Force old cpu-only window code
+* `--filter FILTER`:  Select an upscale filter at startup
+* `--fullscreen`:  Start in fullscreen mode
+
+Note that the cpu-only window does not support fullscreen nor upscale filters.
+
+Unless --no-gpu is given, uw8 will first try to open a gpu accelerated window, falling back to the old cpu-only window if that fails.
+Therefore you should rarely need to manually pass --no-gpu. If you prefer the old pixel doubling look to the now default crt filter,
+you can just pass `--filter nearest` or `--filter 1`.
+
+The upscale filter options are:
+```
+1, nearest              : Anti-aliased nearest filter
+2, fast_crt             : Very simple, cheap crt filter, not very good below a window size of 960x720
+3, ss_crt               : Super sampled crt filter, a little more demanding on the GPU but scales well to smaller window sizes
+4, chromatic_crt        : Variant of fast_crt with a slight offset of the three color dots of a pixel, still pretty cheap
+5, auto_crt (default)   : ss_crt below 960x720, chromatic_crt otherwise
+```
+
+You can switch the upscale filter at any time using the keys 1-5. You can toggle fullscreen with F.
+
 ## `uw8 pack`

 Usage:
--- a/site/static/v0.2.1/index.html
+++ b/site/static/v0.2.1/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.1">
            <img class="demonstration-gif" style="width:640px;height:480px;image-rendering:pixelated" src="img/technotunnel.png"></img>
        </a>
    </div>
--- a/src/main.rs
+++ b/src/main.rs
@@ -13,6 +13,7 @@ use uw8::RunWebServer;
 use uw8::Runtime;

 fn main() -> Result<()> {
+    env_logger::Builder::from_env(env_logger::Env::default()).init();
    let mut args = Arguments::from_env();

    // try to enable ansi support in win10 cmd shell
@@ -35,7 +36,7 @@ fn main() -> Result<()> {
            println!();
            println!("Usage:");
            #[cfg(any(feature = "native", feature = "browser"))]
-            println!("  uw8 run [-t/--timeout <frames>] [--no-gpu] [--b/--browser] [-w/--watch] [-p/--pack] [-u/--uncompressed] [-l/--level] [-o/--output <out-file>] <file>");
+            println!("  uw8 run [-t/--timeout <frames>] [--b/--browser] [-w/--watch] [-p/--pack] [-u/--uncompressed] [-l/--level] [-o/--output <out-file>] <file>");
            println!("  uw8 pack [-u/--uncompressed] [-l/--level] <in-file> <out-file>");
            println!("  uw8 unpack <in-file> <out-file>");
            println!("  uw8 compile [-d/--debug] <in-file> <out-file>");
@@ -54,8 +55,6 @@ fn run(mut args: Arguments) -> Result<()> {
    let watch_mode = args.contains(["-w", "--watch"]);
    #[allow(unused)]
    let timeout: Option<u32> = args.opt_value_from_str(["-t", "--timeout"])?;
-    #[allow(unused)]
-    let gpu = !args.contains("--no-gpu");

    let mut config = Config::default();
    if args.contains(["-p", "--pack"]) {
@@ -82,7 +81,17 @@ fn run(mut args: Arguments) -> Result<()> {
    #[cfg(not(feature = "native"))]
    let run_browser = args.contains(["-b", "--browser"]) || true;

-    let disable_audio = args.contains(["-m", "--disable-audio"]);
+    #[allow(unused)]
+    let disable_audio = args.contains(["-m", "--no-audio"]);
+
+    #[cfg(feature = "native")]
+    let window_config = {
+        let mut config = uw8_window::WindowConfig::default();
+        if !run_browser {
+            config.parse_arguments(&mut args);
+        }
+        config
+    };

    let filename = args.free_from_os_str::<PathBuf, bool>(|s| Ok(s.into()))?;

@@ -95,7 +104,7 @@ fn run(mut args: Arguments) -> Result<()> {
        unimplemented!();
        #[cfg(feature = "native")]
        {
-            let mut microw8 = MicroW8::new(timeout, gpu)?;
+            let mut microw8 = MicroW8::new(timeout, window_config)?;
            if disable_audio {
                microw8.disable_audio();
            }
@@ -167,7 +176,8 @@ fn load_cart(filename: &Path, config: &Config) -> (Result<Vec<u8>>, Vec<PathBuf>
        if let Some(ref pack_config) = config.pack {
            cart = uw8_tool::pack(&cart, pack_config)?;
            println!(
-                "\npacked size: {:.2} bytes",
+                "\npacked size: {} bytes ({:.2})",
+                cart.len(),
                uw8_tool::compressed_size(&cart)
            );
        }
--- a/src/run-web.html
+++ b/src/run-web.html
--- a/src/run_native.rs
+++ b/src/run_native.rs
@@ -5,23 +5,20 @@ use std::{thread, time::Instant};
 use anyhow::{anyhow, Result};
 use cpal::traits::*;
 use rubato::Resampler;
+use uw8_window::{Window, WindowConfig};
 use wasmtime::{
    Engine, GlobalType, Memory, MemoryType, Module, Mutability, Store, TypedFunc, ValType,
 };

 pub struct MicroW8 {
-    tx: mpsc::SyncSender<Option<UW8Instance>>,
-    rx: mpsc::Receiver<UIEvent>,
+    window: Window,
    stream: Option<cpal::Stream>,
    engine: Engine,
    loader_module: Module,
    disable_audio: bool,
    module_data: Option<Vec<u8>>,
-}
-
-enum UIEvent {
-    Error(Result<()>),
-    Reset,
+    timeout: u32,
+    instance: Option<UW8Instance>,
 }

 struct UW8Instance {
@@ -48,7 +45,7 @@ struct UW8WatchDog {
 }

 impl MicroW8 {
-    pub fn new(timeout: Option<u32>, gpu: bool) -> Result<MicroW8> {
+    pub fn new(timeout: Option<u32>, window_config: WindowConfig) -> Result<MicroW8> {
        let mut config = wasmtime::Config::new();
        config.cranelift_opt_level(wasmtime::OptLevel::Speed);
        if timeout.is_some() {
@@ -59,39 +56,17 @@ impl MicroW8 {
        let loader_module =
            wasmtime::Module::new(&engine, include_bytes!("../platform/bin/loader.wasm"))?;

-        let (to_ui_tx, to_ui_rx) = mpsc::sync_channel(2);
-        let (from_ui_tx, from_ui_rx) = mpsc::sync_channel(1);
-
-        std::thread::spawn(move || {
-            let mut state = State {
-                instance: None,
-                timeout: timeout.unwrap_or(0),
-            };
-
-            uw8_window::run(gpu, move |framebuffer, gamepad, reset| {
-                while let Ok(instance) = to_ui_rx.try_recv() {
-                    state.instance = instance;
-                }
-
-                if reset {
-                    from_ui_tx.send(UIEvent::Reset).unwrap();
-                }
-
-                state.run_frame(framebuffer, gamepad).unwrap_or_else(|err| {
-                    from_ui_tx.send(UIEvent::Error(Err(err))).unwrap();
-                    Instant::now()
-                })
-            });
-        });
+        let window = Window::new(window_config)?;

        Ok(MicroW8 {
-            tx: to_ui_tx,
-            rx: from_ui_rx,
+            window,
            stream: None,
            engine,
            loader_module,
            disable_audio: false,
            module_data: None,
+            timeout: timeout.unwrap_or(0),
+            instance: None,
        })
    }

@@ -102,12 +77,12 @@ impl MicroW8 {

 impl super::Runtime for MicroW8 {
    fn is_open(&self) -> bool {
-        true
+        self.window.is_open()
    }

    fn load(&mut self, module_data: &[u8]) -> Result<()> {
        self.stream = None;
-        self.tx.send(None)?;
+        self.instance = None;

        let mut store = wasmtime::Store::new(&self.engine, ());
        store.set_epoch_deadline(60);
@@ -159,6 +134,10 @@ impl super::Runtime for MicroW8 {
        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)
        } else {
@@ -174,7 +153,7 @@ impl super::Runtime for MicroW8 {
            }
        };

-        self.tx.send(Some(UW8Instance {
+        self.instance = Some(UW8Instance {
            store,
            memory,
            end_frame,
@@ -182,56 +161,36 @@ impl super::Runtime for MicroW8 {
            start_time: Instant::now(),
            watchdog,
            sound_tx,
-        }))?;
+        });
        self.stream = stream;
        self.module_data = Some(module_data.into());
        Ok(())
    }

    fn run_frame(&mut self) -> Result<()> {
-        if let Ok(event) = self.rx.try_recv() {
-            match event {
-                UIEvent::Error(err) => err,
-                UIEvent::Reset => {
-                    if let Some(module_data) = self.module_data.take() {
-                        self.load(&module_data)
-                    } else {
-                        Ok(())
-                    }
-                }
+        let input = self.window.begin_frame();
+
+        if input.reset {
+            if let Some(module_data) = self.module_data.take() {
+                self.load(&module_data)?;
            }
-        } else {
-            Ok(())
        }
-    }
-}

-struct State {
-    instance: Option<UW8Instance>,
-    timeout: u32,
-}
-
-impl State {
-    fn run_frame(
-        &mut self,
-        framebuffer: &mut dyn uw8_window::Framebuffer,
-        gamepad: u32,
-    ) -> Result<Instant> {
        let now = Instant::now();
-        let mut result = Ok(now);
+        let mut result = Ok(());
        if let Some(mut instance) = self.instance.take() {
            let time = (now - instance.start_time).as_millis() as i32;
-            {
+            let next_frame = {
                let offset = ((time as u32 as i64 * 6) % 100 - 50) / 6;
                let max = now + Duration::from_millis(17);
                let next_center = now + Duration::from_millis((16 - offset) as u64);
-                result = Ok(next_center.min(max));
-            }
+                next_center.min(max)
+            };

            {
                let mem = instance.memory.data_mut(&mut instance.store);
                mem[64..68].copy_from_slice(&time.to_le_bytes());
-                mem[68..72].copy_from_slice(&gamepad.to_le_bytes());
+                mem[68..72].copy_from_slice(&input.gamepads);
            }

            instance.store.set_epoch_deadline(self.timeout as u64);
@@ -255,14 +214,16 @@ impl State {

            let framebuffer_mem = &memory[120..(120 + 320 * 240)];
            let palette_mem = &memory[0x13000..];
-            framebuffer.update(framebuffer_mem, palette_mem);
+            self.window
+                .end_frame(framebuffer_mem, palette_mem, next_frame);

            if result.is_ok() {
                self.instance = Some(instance);
            }
        }

-        Ok(result?)
+        result?;
+        Ok(())
    }
 }

@@ -357,7 +318,7 @@ fn init_sound(

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

    let host = cpal::default_host();
    let device = host
@@ -385,7 +346,7 @@ fn init_sound(
        .ok_or_else(|| anyhow!("Could not find float 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,
@@ -462,6 +423,14 @@ fn init_sound(
                    mem[64..68].copy_from_slice(&current_time.to_le_bytes());
                }

+                fn clamp_sample(s: f32) -> f32 {
+                    if s.is_nan() {
+                        0.0
+                    } else {
+                        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]
@@ -472,10 +441,12 @@ fn init_sound(
                            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));
+                                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);
                            }

@@ -501,7 +472,7 @@ fn init_sound(
                    }
                } else {
                    for v in buffer {
-                        *v = snd.call(&mut store, (sample_index,)).unwrap_or(0.0);
+                        *v = clamp_sample(snd.call(&mut store, (sample_index,)).unwrap_or(0.0));
                        sample_index = sample_index.wrapping_add(1);
                    }
                }
--- 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);
        }
--- 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/src/base_module.rs
+++ b/uw8-tool/src/base_module.rs
@@ -167,6 +167,7 @@ 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));

        for i in functions.len()..64 {
            add_function(
--- a/uw8-tool/src/pack.rs
+++ b/uw8-tool/src/pack.rs
@@ -220,6 +220,11 @@ impl<'a> ParsedModule<'a> {
                    validate_table_section(reader)?;
                    table_section = Some(Section::new(range, ()));
                }
+                Payload::MemorySection(reader) => {
+                    if reader.get_count() != 0 {
+                        bail!("Found non-empty MemorySection. Memory has to be imported!");
+                    }
+                }
                Payload::ElementSection(mut reader) => {
                    let mut elements = Vec::with_capacity(reader.get_count() as usize);
                    for _ in 0..reader.get_count() {
--- a/uw8-window/Cargo.lock
+++ b/uw8-window/Cargo.lock
@@ -986,6 +986,12 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"

+[[package]]
+name = "pico-args"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.9"
@@ -1296,6 +1302,7 @@ dependencies = [
 "env_logger",
 "log",
 "minifb",
+ "pico-args",
 "pollster",
 "wgpu",
 "winapi",
--- a/uw8-window/Cargo.toml
+++ b/uw8-window/Cargo.toml
@@ -9,6 +9,7 @@ edition = "2021"
 winit = "0.26.1"
 env_logger = "0.9"
 log = "0.4"
+pico-args = "0.4"
 wgpu = "0.13.1"
 pollster = "0.2"
 bytemuck = { version = "1.4", features = [ "derive" ] }
--- a/uw8-window/src/cpu.rs
+++ b/uw8-window/src/cpu.rs
@@ -1,7 +1,8 @@
 use std::time::Instant;

-use crate::Framebuffer;
-use minifb::{Key, Window, WindowOptions};
+use crate::{Input, WindowImpl};
+use anyhow::Result;
+use minifb::{Key, WindowOptions};

 static GAMEPAD_KEYS: &[Key] = &[
    Key::Up,
@@ -14,58 +15,53 @@ static GAMEPAD_KEYS: &[Key] = &[
    Key::S,
 ];

-pub fn run(mut update: Box<dyn FnMut(&mut dyn Framebuffer, u32, bool) -> Instant + 'static>) -> ! {
-    #[cfg(target_os = "windows")]
-    unsafe {
-        winapi::um::timeapi::timeBeginPeriod(1);
-    }
+pub struct Window {
+    window: minifb::Window,
+    buffer: Vec<u32>,
+}

-    let mut buffer: Vec<u32> = vec![0; 320 * 240];
-
-    let options = WindowOptions {
-        scale: minifb::Scale::X2,
-        scale_mode: minifb::ScaleMode::AspectRatioStretch,
-        resize: true,
-        ..Default::default()
-    };
-    let mut window = Window::new("MicroW8", 320, 240, options).unwrap();
-
-    let mut next_frame = Instant::now();
-    while window.is_open() && !window.is_key_down(Key::Escape) {
-        if let Some(sleep) = next_frame.checked_duration_since(Instant::now()) {
-            std::thread::sleep(sleep);
+impl Window {
+    pub fn new() -> Result<Window> {
+        #[cfg(target_os = "windows")]
+        unsafe {
+            winapi::um::timeapi::timeBeginPeriod(1);
        }

-        let mut gamepad = 0;
-        for key in window.get_keys() {
+        let buffer: Vec<u32> = vec![0; 320 * 240];
+
+        let options = WindowOptions {
+            scale: minifb::Scale::X2,
+            scale_mode: minifb::ScaleMode::AspectRatioStretch,
+            resize: true,
+            ..Default::default()
+        };
+        let window = minifb::Window::new("MicroW8", 320, 240, options).unwrap();
+
+        Ok(Window { window, buffer })
+    }
+}
+
+impl WindowImpl for Window {
+    fn begin_frame(&mut self) -> Input {
+        let mut gamepads = [0u8; 4];
+        for key in self.window.get_keys() {
            if let Some(index) = GAMEPAD_KEYS
                .iter()
                .enumerate()
                .find(|(_, &k)| k == key)
                .map(|(i, _)| i)
            {
-                gamepad |= 1 << index;
+                gamepads[0] |= 1 << index;
            }
        }

-        next_frame = update(
-            &mut CpuFramebuffer {
-                buffer: &mut buffer,
-            },
-            gamepad,
-            window.is_key_pressed(Key::R, minifb::KeyRepeat::No),
-        );
-        window.update_with_buffer(&buffer, 320, 240).unwrap();
+        Input {
+            gamepads,
+            reset: self.window.is_key_pressed(Key::R, minifb::KeyRepeat::No),
+        }
    }
-    std::process::exit(0);
-}

-struct CpuFramebuffer<'a> {
-    buffer: &'a mut Vec<u32>,
-}
-
-impl<'a> Framebuffer for CpuFramebuffer<'a> {
-    fn update(&mut self, framebuffer: &[u8], palette: &[u8]) {
+    fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
        for (i, &color_index) in framebuffer.iter().enumerate() {
            let offset = color_index as usize * 4;
            self.buffer[i] = 0xff000000
@@ -73,5 +69,15 @@ impl<'a> Framebuffer for CpuFramebuffer<'a> {
                | ((palette[offset + 1] as u32) << 8)
                | palette[offset + 2] as u32;
        }
+        self.window
+            .update_with_buffer(&self.buffer, 320, 240)
+            .unwrap();
+        if let Some(sleep) = next_frame.checked_duration_since(Instant::now()) {
+            std::thread::sleep(sleep);
+        }
+    }
+
+    fn is_open(&self) -> bool {
+        self.window.is_open() && !self.window.is_key_down(Key::Escape)
    }
 }
--- a/uw8-window/src/gpu/crt.rs
+++ b/uw8-window/src/gpu/crt.rs
@@ -112,7 +112,7 @@ impl CrtFilter {
 }

 impl Filter for CrtFilter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
        let uniforms = Uniforms {
            texture_scale: texture_scale_from_resolution(new_size),
        };
--- a/uw8-window/src/gpu/fast_crt.rs
+++ b/uw8-window/src/gpu/fast_crt.rs
@@ -15,6 +15,7 @@ impl FastCrtFilter {
        screen: &wgpu::TextureView,
        resolution: PhysicalSize<u32>,
        surface_format: wgpu::TextureFormat,
+        chromatic: bool,
    ) -> FastCrtFilter {
        let uniforms = Uniforms {
            texture_scale: texture_scale_from_resolution(resolution),
@@ -104,7 +105,11 @@ impl FastCrtFilter {
            },
            fragment: Some(wgpu::FragmentState {
                module: &shader,
-                entry_point: "fs_main",
+                entry_point: if chromatic {
+                    "fs_main_chromatic"
+                } else {
+                    "fs_main"
+                },
                targets: &[Some(wgpu::ColorTargetState {
                    format: surface_format,
                    blend: None,
@@ -126,7 +131,7 @@ impl FastCrtFilter {
 }

 impl Filter for FastCrtFilter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
        let uniforms = Uniforms {
            texture_scale: texture_scale_from_resolution(new_size),
        };
--- a/uw8-window/src/gpu/fast_crt.wgsl
+++ b/uw8-window/src/gpu/fast_crt.wgsl
@@ -34,10 +34,9 @@ fn col_factor(offset: f32) -> f32 {
    return 1.0 / (1.0 + offset * offset * 16.0);
 }

-@fragment
-fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    let base = round(in.tex_coords) - vec2<f32>(0.5);
-    let frac = in.tex_coords - base;
+fn sample_screen(tex_coords: vec2<f32>) -> vec4<f32> {
+    let base = round(tex_coords) - vec2<f32>(0.5);
+    let frac = tex_coords - base;
    
    let top_factor = row_factor(frac.y);
    let bottom_factor = row_factor(frac.y - 1.0);
@@ -52,3 +51,16 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
    return textureSample(screen_texture, linear_sampler, vec2<f32>(u, v) / vec2<f32>(320.0, 240.0)) * (top_factor + bottom_factor) * (left_factor + right_factor) * 1.1;
 }

+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return sample_screen(in.tex_coords);
+}
+
+@fragment
+fn fs_main_chromatic(in: VertexOutput) -> @location(0) vec4<f32> {
+    let r = sample_screen(in.tex_coords + vec2<f32>(0.2, 0.2)).r;
+    let g = sample_screen(in.tex_coords + vec2<f32>(0.07, -0.27)).g;
+    let b = sample_screen(in.tex_coords + vec2<f32>(-0.27, 0.07)).b;
+    return vec4<f32>(r, g, b, 1.0);
+}
+
--- a/uw8-window/src/gpu/mod.rs
+++ b/uw8-window/src/gpu/mod.rs
@@ -1,4 +1,4 @@
-use crate::Framebuffer;
+use crate::{Input, WindowConfig, WindowImpl};
 use anyhow::{anyhow, Result};
 use std::{num::NonZeroU32, time::Instant};

@@ -9,12 +9,7 @@ use winit::{
    window::{Fullscreen, WindowBuilder},
 };

-#[cfg(target_os = "macos")]
-use winit::platform::macos::EventLoopExtMacOS;
-#[cfg(target_os = "linux")]
-use winit::platform::unix::EventLoopExtUnix;
-#[cfg(target_os = "windows")]
-use winit::platform::windows::EventLoopExtWindows;
+use winit::platform::run_return::EventLoopExtRunReturn;

 mod crt;
 mod fast_crt;
@@ -25,23 +20,35 @@ use fast_crt::FastCrtFilter;
 use square::SquareFilter;

 pub struct Window {
-    event_loop: EventLoop<()>,
-    window: winit::window::Window,
-    instance: wgpu::Instance,
+    _instance: wgpu::Instance,
    surface: wgpu::Surface,
-    adapter: wgpu::Adapter,
+    _adapter: wgpu::Adapter,
    device: wgpu::Device,
    queue: wgpu::Queue,
+    palette_screen_mode: PaletteScreenMode,
+    surface_config: wgpu::SurfaceConfiguration,
+    filter: Box<dyn Filter>,
+    event_loop: EventLoop<()>,
+    window: winit::window::Window,
+    gamepads: [u8; 4],
+    next_frame: Instant,
+    is_fullscreen: bool,
+    is_open: bool,
 }

 impl Window {
-    pub fn new() -> Result<Window> {
-        async fn create() -> Result<Window> {
-            let event_loop = EventLoop::new_any_thread();
+    pub fn new(window_config: WindowConfig) -> Result<Window> {
+        async fn create(window_config: WindowConfig) -> Result<Window> {
+            let event_loop = EventLoop::new();
            let window = WindowBuilder::new()
                .with_inner_size(PhysicalSize::new(640u32, 480))
                .with_min_inner_size(PhysicalSize::new(320u32, 240))
                .with_title("MicroW8")
+                .with_fullscreen(if window_config.fullscreen {
+                    Some(Fullscreen::Borderless(None))
+                } else {
+                    None
+                })
                .build(&event_loop)?;

            window.set_cursor_visible(false);
@@ -61,70 +68,68 @@ impl Window {
                .request_device(&wgpu::DeviceDescriptor::default(), None)
                .await?;

+            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,
+            };
+
+            let filter: Box<dyn Filter> = create_filter(
+                &device,
+                &palette_screen_mode.screen_view,
+                window.inner_size(),
+                surface_config.format,
+                window_config.filter,
+            );
+
+            surface.configure(&device, &surface_config);
+
            Ok(Window {
                event_loop,
                window,
-                instance,
+                _instance: instance,
                surface,
-                adapter,
+                _adapter: adapter,
                device,
                queue,
+                palette_screen_mode,
+                surface_config,
+                filter,
+                gamepads: [0; 4],
+                next_frame: Instant::now(),
+                is_fullscreen: window_config.fullscreen,
+                is_open: true,
            })
        }

-        pollster::block_on(create())
+        pollster::block_on(create(window_config))
    }
+}

-    pub fn run(
-        self,
-        mut update: Box<dyn FnMut(&mut dyn Framebuffer, u32, bool) -> Instant + 'static>,
-    ) -> ! {
-        let Window {
-            event_loop,
-            window,
-            instance,
-            surface,
-            adapter,
-            device,
-            queue,
-        } = self;
-
-        let palette_screen_mode = PaletteScreenMode::new(&device);
-
-        let mut 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,
-        };
-
-        let mut filter: Box<dyn Filter> = Box::new(CrtFilter::new(
-            &device,
-            &palette_screen_mode.screen_view,
-            window.inner_size(),
-            surface_config.format,
-        ));
-
-        surface.configure(&device, &surface_config);
-
+impl WindowImpl for Window {
+    fn begin_frame(&mut self) -> Input {
        let mut reset = false;
-        let mut gamepad = 0;
-
-        event_loop.run(move |event, _, control_flow| {
-            let _ = (&window, &instance, &surface, &adapter, &device);
-
+        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) => {
-                        surface_config.width = new_size.width;
-                        surface_config.height = new_size.height;
-                        surface.configure(&device, &surface_config);
-                        filter.resize(&queue, 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::CloseRequested => *control_flow = ControlFlow::Exit,
                    WindowEvent::KeyboardInput { input, .. } => {
-                        fn gamepad_button(input: &winit::event::KeyboardInput) -> u32 {
+                        fn gamepad_button(input: &winit::event::KeyboardInput) -> u8 {
                            match input.scancode {
                                44 => 16,
                                45 => 32,
@@ -141,124 +146,195 @@ impl Window {
                        }
                        if input.state == winit::event::ElementState::Pressed {
                            match input.virtual_keycode {
-                                Some(VirtualKeyCode::Escape) => *control_flow = ControlFlow::Exit,
+                                Some(VirtualKeyCode::Escape) => {
+                                    self.is_open = false;
+                                    *control_flow = ControlFlow::Exit;
+                                }
                                Some(VirtualKeyCode::F) => {
-                                    window.set_fullscreen(if window.fullscreen().is_some() {
+                                    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) => {
-                                    filter = Box::new(SquareFilter::new(
-                                        &device,
-                                        &palette_screen_mode.screen_view,
-                                        window.inner_size(),
-                                        surface_config.format,
-                                    ))
-                                }
-                                Some(VirtualKeyCode::Key2) => {
-                                    filter = Box::new(FastCrtFilter::new(
-                                        &device,
-                                        &palette_screen_mode.screen_view,
-                                        window.inner_size(),
-                                        surface_config.format,
-                                    ))
-                                }
-                                Some(VirtualKeyCode::Key3) => {
-                                    filter = Box::new(CrtFilter::new(
-                                        &device,
-                                        &palette_screen_mode.screen_view,
-                                        window.inner_size(),
-                                        surface_config.format,
-                                    ))
-                                }
+                                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),
                                _ => (),
                            }

-                            gamepad |= gamepad_button(&input);
+                            self.gamepads[0] |= gamepad_button(&input);
                        } else {
-                            gamepad &= !gamepad_button(&input);
+                            self.gamepads[0] &= !gamepad_button(&input);
                        }
                    }
                    _ => (),
                },
-                Event::MainEventsCleared => {
-                    if let ControlFlow::WaitUntil(t) = *control_flow {
-                        if Instant::now() < t {
-                            return;
-                        }
-                    }
-                    let next_frame = update(
-                        &mut GpuFramebuffer {
-                            queue: &queue,
-                            framebuffer: &palette_screen_mode,
-                        },
-                        gamepad,
-                        reset,
-                    );
-                    reset = false;
-                    *control_flow = ControlFlow::WaitUntil(next_frame);
-
-                    let output = surface.get_current_texture().unwrap();
-                    let view = output
-                        .texture
-                        .create_view(&wgpu::TextureViewDescriptor::default());
-                    let mut encoder = device
-                        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
-
-                    palette_screen_mode.resolve_screen(&mut encoder);
-
+                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
                    {
-                        let mut render_pass =
-                            encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                                label: None,
-                                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                                    view: &view,
-                                    resolve_target: None,
-                                    ops: wgpu::Operations {
-                                        load: wgpu::LoadOp::Clear(wgpu::Color {
-                                            r: 0.0,
-                                            g: 0.0,
-                                            b: 0.0,
-                                            a: 1.0,
-                                        }),
-                                        store: true,
-                                    },
-                                })],
-                                depth_stencil_attachment: None,
-                            });
-
-                        filter.render(&mut render_pass);
+                        *control_flow = ControlFlow::Exit
                    }
-
-                    queue.submit(std::iter::once(encoder.finish()));
-                    output.present();
                }
                _ => (),
            }
+            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,
+                );
+            }
        });
+        Input {
+            gamepads: self.gamepads,
+            reset,
+        }
+    }
+
+    fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
+        self.next_frame = next_frame;
+        self.palette_screen_mode
+            .write_framebuffer(&self.queue, framebuffer);
+        self.palette_screen_mode.write_palette(&self.queue, palette);
+
+        let output = self.surface.get_current_texture().unwrap();
+        let view = output
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+
+        self.palette_screen_mode.resolve_screen(&mut encoder);
+
+        {
+            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color {
+                            r: 0.0,
+                            g: 0.0,
+                            b: 0.0,
+                            a: 1.0,
+                        }),
+                        store: true,
+                    },
+                })],
+                depth_stencil_attachment: None,
+            });
+
+            self.filter.render(&mut render_pass);
+        }
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+        output.present();
+    }
+
+    fn is_open(&self) -> bool {
+        self.is_open
    }
 }

-struct GpuFramebuffer<'a> {
-    framebuffer: &'a PaletteScreenMode,
-    queue: &'a wgpu::Queue,
-}
-
-impl<'a> Framebuffer for GpuFramebuffer<'a> {
-    fn update(&mut self, pixels: &[u8], palette: &[u8]) {
-        self.framebuffer.write_framebuffer(self.queue, pixels);
-        self.framebuffer.write_palette(self.queue, palette);
+fn create_filter(
+    device: &wgpu::Device,
+    screen_texture: &wgpu::TextureView,
+    window_size: PhysicalSize<u32>,
+    surface_format: wgpu::TextureFormat,
+    filter: u32,
+) -> Box<dyn Filter> {
+    match filter {
+        1 => Box::new(SquareFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+        )),
+        2 => Box::new(FastCrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+            false,
+        )),
+        3 => Box::new(CrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+        )),
+        4 => Box::new(FastCrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+            true,
+        )),
+        _ => Box::new(AutoCrtFilter::new(
+            device,
+            screen_texture,
+            window_size,
+            surface_format,
+        )),
    }
 }

 trait Filter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>);
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>);
    fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>);
 }

+struct AutoCrtFilter {
+    small: CrtFilter,
+    large: FastCrtFilter,
+    resolution: PhysicalSize<u32>,
+}
+
+impl AutoCrtFilter {
+    fn new(
+        device: &wgpu::Device,
+        screen: &wgpu::TextureView,
+        resolution: PhysicalSize<u32>,
+        surface_format: wgpu::TextureFormat,
+    ) -> AutoCrtFilter {
+        let small = CrtFilter::new(device, screen, resolution, surface_format);
+        let large = FastCrtFilter::new(device, screen, resolution, surface_format, true);
+        AutoCrtFilter {
+            small,
+            large,
+            resolution,
+        }
+    }
+}
+
+impl Filter for AutoCrtFilter {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+        self.small.resize(queue, new_size);
+        self.large.resize(queue, new_size);
+        self.resolution = new_size;
+    }
+
+    fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
+        if self.resolution.width < 960 || self.resolution.height < 720 {
+            self.small.render(render_pass);
+        } else {
+            self.large.render(render_pass);
+        }
+    }
+}
+
 struct PaletteScreenMode {
    framebuffer: wgpu::Texture,
    palette: wgpu::Texture,
--- a/uw8-window/src/gpu/square.rs
+++ b/uw8-window/src/gpu/square.rs
@@ -126,7 +126,7 @@ impl SquareFilter {
 }

 impl Filter for SquareFilter {
-    fn resize(&self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
+    fn resize(&mut self, queue: &wgpu::Queue, new_size: PhysicalSize<u32>) {
        let uniforms = Uniforms {
            texture_scale: texture_scale_from_resolution(new_size),
        };
--- a/uw8-window/src/lib.rs
+++ b/uw8-window/src/lib.rs
@@ -1,24 +1,117 @@
+use anyhow::Result;
 use std::time::Instant;

 mod cpu;
 mod gpu;

-pub fn run<F: 'static + FnMut(&mut dyn Framebuffer, u32, bool) -> Instant>(
-    gpu: bool,
-    update: F,
-) -> ! {
-    if gpu {
-        match gpu::Window::new() {
-            Ok(window) => window.run(Box::new(update)),
-            Err(err) => eprintln!(
-                "Failed to create gpu window: {}\nFalling back to cpu window",
-                err
-            ),
-        }
-    }
-    cpu::run(Box::new(update));
+pub struct Window {
+    inner: Box<dyn WindowImpl>,
+    fps_counter: Option<FpsCounter>,
 }

-pub trait Framebuffer {
-    fn update(&mut self, pixels: &[u8], palette: &[u8]);
+struct FpsCounter {
+    start: Instant,
+    num_frames: u32,
+}
+
+impl Window {
+    pub fn new(config: WindowConfig) -> Result<Window> {
+        let fps_counter = if config.fps_counter {
+            Some(FpsCounter {
+                start: Instant::now(),
+                num_frames: 0,
+            })
+        } else {
+            None
+        };
+        if config.enable_gpu {
+            match gpu::Window::new(config) {
+                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 {
+            inner: Box::new(window),
+            fps_counter,
+        })
+    }
+
+    pub fn begin_frame(&mut self) -> Input {
+        self.inner.begin_frame()
+    }
+    pub fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant) {
+        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.inner.is_open()
+    }
+}
+
+#[derive(Debug)]
+pub struct WindowConfig {
+    enable_gpu: bool,
+    filter: u32,
+    fullscreen: bool,
+    fps_counter: bool,
+}
+
+impl Default for WindowConfig {
+    fn default() -> WindowConfig {
+        WindowConfig {
+            enable_gpu: true,
+            filter: 5,
+            fullscreen: false,
+            fps_counter: false,
+        }
+    }
+}
+
+impl WindowConfig {
+    pub fn parse_arguments(&mut self, args: &mut pico_args::Arguments) {
+        self.enable_gpu = !args.contains("--no-gpu");
+        if let Some(filter) = args.opt_value_from_str::<_, String>("--filter").unwrap() {
+            self.filter = match filter.as_str() {
+                "1" | "nearest" => 1,
+                "2" | "fast_crt" => 2,
+                "3" | "ss_crt" => 3,
+                "4" | "chromatic" => 4,
+                "5" | "auto_crt" => 5,
+                o => {
+                    println!("Unknown --filter '{}'", o);
+                    std::process::exit(1);
+                }
+            }
+        }
+        self.fullscreen = args.contains("--fullscreen");
+        self.fps_counter = args.contains("--fps");
+    }
+}
+
+pub struct Input {
+    pub gamepads: [u8; 4],
+    pub reset: bool,
+}
+
+trait WindowImpl {
+    fn begin_frame(&mut self) -> Input;
+    fn end_frame(&mut self, framebuffer: &[u8], palette: &[u8], next_frame: Instant);
+    fn is_open(&self) -> bool;
 }
--- a/uw8-window/src/main.rs
+++ b/uw8-window/src/main.rs
@@ -1,10 +1,13 @@
 use std::time::Instant;
+use uw8_window::WindowConfig;

 fn main() {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

+    let mut args = pico_args::Arguments::from_env();
+
    let mut framebuffer = vec![0u8; 320 * 240];
-    let start_time = Instant::now();
+    let mut start_time = Instant::now();

    let mut palette = vec![0u32; 256];
    for i in 0..256 {
@@ -18,11 +21,19 @@ fn main() {
    let mut fps_start = Instant::now();
    let mut fps_counter = 0;

-    uw8_window::run(true, move |gpu_framebuffer, _gamepads, _reset| {
-        for _ in 0..1 {
-            draw_frame(&mut framebuffer, start_time.elapsed().as_secs_f32());
+    let mut window_config = WindowConfig::default();
+    window_config.parse_arguments(&mut args);
+
+    let mut window = uw8_window::Window::new(window_config).unwrap();
+
+    while window.is_open() {
+        let input = window.begin_frame();
+        if input.reset {
+            start_time = Instant::now();
        }
-        gpu_framebuffer.update(&framebuffer, bytemuck::cast_slice(&palette));
+        draw_frame(&mut framebuffer, start_time.elapsed().as_secs_f32());
+        window.end_frame(&framebuffer, bytemuck::cast_slice(&palette), Instant::now());
+
        fps_counter += 1;
        let elapsed = fps_start.elapsed().as_secs_f32();
        if elapsed >= 1.0 {
@@ -30,8 +41,7 @@ fn main() {
            fps_start = Instant::now();
            fps_counter = 0;
        }
-        Instant::now()
-    });
+    }
 }

 fn draw_frame(framebuffer: &mut [u8], time: f32) {
--- 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/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	a20e569723	clamp snd samples into valid -1.0..1.0 range	2024-06-09 00:46:16 +02:00
Dennis Ranke	8a473cc9b9	call an exported start function if it exists	2024-06-09 00:35:25 +02:00
Dennis Ranke	4a4beded11	only open browser once cart has been compiled succesfully	2024-06-09 00:35:13 +02:00
Dennis Ranke	9d629be747	fix control codes 4-6 as parameters to other control codes	2024-06-09 00:33:49 +02: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
Dennis Ranke	760664eb77	add some command line switches for the gpu window	2022-07-23 22:34:59 +02:00
Dennis Ranke	465e66ff4b	slight improvement to packed size display	2022-07-23 00:30:14 +02:00
Dennis Ranke	e4579d81bc	add chromatic version of fast crt shader + auto crt shader	2022-07-21 23:03:52 +02:00
Dennis Ranke	1f5042059c	fix inputs getting stuck	2022-07-21 19:37:36 +02:00
Dennis Ranke	499bb02f2c	restructure control flow of uw8-window to hopefully make it work on MacOS	2022-07-21 08:51:17 +02:00
				`@@ -0,0 +1 @@`
				`* add support for 16bit sound (not just float)`