From c4924f756da14cc4c3e47ebe5e11b70fdeccf8b4 Mon Sep 17 00:00:00 2001
From: Hirek193 <polomarket73@gmail.com>
Date: Tue, 10 Nov 2026 15:29:25 +0100
Subject: [PATCH] Lua script screens beside the WebAssembly ones

---
 CMakeLists.txt                                |  16 +-
 CMake_modules/wamr/CMakeLists.txt             |   2 +-
 application/application.cpp                   |   9 +-
 application/application.h                     |  12 +-
 model/Texture.cpp                             |   4 +-
 script_screens_doc.md                         | 199 ++++
 scripting/luaprogram.cpp                      | 847 ++++++++++++++++
 scripting/scriptscreendrawing.cpp             | 294 ++++++
 scripting/scriptscreendrawing.h               | 126 +++
 ...eenkernels.cpp => scriptscreenkernels.cpp} |   6 +-
 ...mscreenkernels.h => scriptscreenkernels.h} |   6 +-
 scripting/scriptscreenprogram.h               |  92 ++
 ...mscreenrules.cpp => scriptscreenrules.cpp} |   6 +-
 ...{wasmscreenrules.h => scriptscreenrules.h} |  17 +-
 scripting/scriptscreens.cpp                   | 511 ++++++++++
 scripting/scriptscreens.h                     |  98 ++
 scripting/wasmprogram.cpp                     | 630 ++++++++++++
 scripting/wasmscreens.cpp                     | 942 ------------------
 scripting/wasmscreens.h                       |  72 --
 scripting/wasmscreensstub.cpp                 |  51 -
 tests/unit/CMakeLists.txt                     |  12 +-
 tests/unit/run_tests.cmake                    |   8 +
 tests/unit/test_script_screen_drawing.cpp     | 120 +++
 tests/unit/test_script_screen_host.cpp        | 596 +++++++++++
 ...els.cpp => test_script_screen_kernels.cpp} |  36 +-
 ...sm_screens.cpp => test_script_screens.cpp} |  46 +-
 tests/unit/test_wasm_host.cpp                 | 288 ------
 utilities/Globals.cpp                         |  28 +-
 utilities/Globals.h                           |   7 +-
 vehicle/DynObj.cpp                            | 116 ++-
 vehicle/DynObj.h                              |  25 +-
 vehicle/Train.cpp                             |  45 +-
 vehicle/Train.h                               |  16 +-
 wasm_screens_doc.md                           | 129 ---
 34 files changed, 3777 insertions(+), 1635 deletions(-)
 create mode 100644 script_screens_doc.md
 create mode 100644 scripting/luaprogram.cpp
 create mode 100644 scripting/scriptscreendrawing.cpp
 create mode 100644 scripting/scriptscreendrawing.h
 rename scripting/{wasmscreenkernels.cpp => scriptscreenkernels.cpp} (98%)
 rename scripting/{wasmscreenkernels.h => scriptscreenkernels.h} (88%)
 create mode 100644 scripting/scriptscreenprogram.h
 rename scripting/{wasmscreenrules.cpp => scriptscreenrules.cpp} (96%)
 rename scripting/{wasmscreenrules.h => scriptscreenrules.h} (75%)
 create mode 100644 scripting/scriptscreens.cpp
 create mode 100644 scripting/scriptscreens.h
 create mode 100644 scripting/wasmprogram.cpp
 delete mode 100644 scripting/wasmscreens.cpp
 delete mode 100644 scripting/wasmscreens.h
 delete mode 100644 scripting/wasmscreensstub.cpp
 create mode 100644 tests/unit/test_script_screen_drawing.cpp
 create mode 100644 tests/unit/test_script_screen_host.cpp
 rename tests/unit/{test_wasm_kernels.cpp => test_script_screen_kernels.cpp} (82%)
 rename tests/unit/{test_wasm_screens.cpp => test_script_screens.cpp} (59%)
 delete mode 100644 tests/unit/test_wasm_host.cpp
 delete mode 100644 wasm_screens_doc.md

diff --git a/CMakeLists.txt b/CMakeLists.txt
index bfa580a3..cbcf185d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -72,7 +72,7 @@ option(WITH_OPENGL_LEGACY "Compile with OpenGL legacy renderer" ON)
 option(WITH_PYTHON "Python 3.14 embedded scripting" ON)
 option(WITH_UART "Compile with libserialport" ON)
 option(WITH_LUA "Compile with lua scripting support" ON)
-option(WITH_WASM "WebAssembly screens (wasmscreen:, wasmdestinationsign:), run by the WAMR interpreter in ref/wamr" ON)
+option(WITH_WASM "WebAssembly script screens (wasmscreen:, wasmdestinationsign:), run by the WAMR interpreter in ref/wamr" ON)
 option(WITH_OPENVR "Compile with OpenVR" OFF)
 option(WITH_ZMQ "Compile with cppzmq" OFF)
 option(WITH_CRASHPAD "Compile with crashpad" OFF)
@@ -322,11 +322,14 @@ if (WITH_LUA)
 	set(SOURCES ${SOURCES} "scripting/lua.cpp")
 endif()
 
+# the script screens (scripting/scriptscreens.cpp), with the Lua and the WebAssembly runtime when they're built
+set(SOURCES ${SOURCES} "scripting/scriptscreens.cpp")
+if (WITH_LUA)
+	set(SOURCES ${SOURCES} "scripting/luaprogram.cpp")
+endif()
 if (WITH_WASM)
 	set(DEFINITIONS ${DEFINITIONS} "WITH_WASM")
-	set(SOURCES ${SOURCES} "scripting/wasmscreens.cpp")
-else()
-	set(SOURCES ${SOURCES} "scripting/wasmscreensstub.cpp")
+	set(SOURCES ${SOURCES} "scripting/wasmprogram.cpp")
 endif()
 
 if (WITHDUMPGEN)
@@ -471,8 +474,9 @@ set(CORE_SOURCES
 "utilities/parser.cpp"
 "utilities/utilities.cpp"
 "scripting/ladderlogic.cpp"
-"scripting/wasmscreenrules.cpp"
-"scripting/wasmscreenkernels.cpp"
+"scripting/scriptscreenrules.cpp"
+"scripting/scriptscreenkernels.cpp"
+"scripting/scriptscreendrawing.cpp"
 "simulation/simulationtestrules.cpp"
 "vehicle/enginestart.cpp"
 "vehicle/handover.cpp"
diff --git a/CMake_modules/wamr/CMakeLists.txt b/CMake_modules/wamr/CMakeLists.txt
index 74e82358..d12d48cd 100644
--- a/CMake_modules/wamr/CMakeLists.txt
+++ b/CMake_modules/wamr/CMakeLists.txt
@@ -1,4 +1,4 @@
-# The WebAssembly Micro Runtime (ref/wamr) for the wasm screens (scripting/wasmscreens.cpp).
+# The WebAssembly Micro Runtime (ref/wamr) for the WebAssembly script screens (scripting/wasmprogram.cpp).
 #
 # Built here, in a directory of its own, because the WAMR build scripts set their configuration with
 # add_definitions() and include_directories(): kept in this directory, none of it reaches the game's sources.
diff --git a/application/application.cpp b/application/application.cpp
index 98f004a9..136aa060 100644
--- a/application/application.cpp
+++ b/application/application.cpp
@@ -425,10 +425,11 @@ int eu07_application::init(int Argc, char *Argv[])
 	{
 		m_taskqueue.init();
 	}
+	crashreport_add_info("luascreens_enabled", Global.luascreens_enabled ? "yes" : "no");
 	crashreport_add_info("wasm_enabled", Global.wasm_enabled ? "yes" : "no");
-	if (Global.wasm_enabled)
+	if (Global.luascreens_enabled || Global.wasm_enabled)
 	{
-		m_wasmqueue.init();
+		m_screenqueue.init();
 	}
 	if ((result = init_modes()) != 0)
 	{
@@ -640,7 +641,7 @@ int eu07_application::run()
 			EditorTerrain.update(Global.pCamera.Pos);
 
 		m_taskqueue.update();
-		m_wasmqueue.update();
+		m_screenqueue.update();
 		opengl_texture::reset_unit_cache();
 
 		if (!GfxRenderer->Render())
@@ -738,7 +739,7 @@ void eu07_application::exit()
 
 	// the python workers detach their GL context on the way out, so they have to be done before the windows they use are destroyed
 	m_taskqueue.exit();
-	m_wasmqueue.exit();
+	m_screenqueue.exit();
 	step("the windows");
 	for (auto *window : m_windows)
 	{
diff --git a/application/application.h b/application/application.h
index 4a1d1ad1..850b66e1 100644
--- a/application/application.h
+++ b/application/application.h
@@ -11,7 +11,7 @@ http://mozilla.org/MPL/2.0/.
 
 #include "application/applicationmode.h"
 #include "scripting/PyInt.h"
-#include "scripting/wasmscreens.h"
+#include "scripting/scriptscreens.h"
 #include "network/manager.h"
 #include "utilities/headtrack.h"
 #ifdef WITH_UART
@@ -50,10 +50,10 @@ public:
     // frees the python gil and swaps out the main thread
     void
         release_python_lock();
-    // the screens drawn by WebAssembly modules
-    wasm_screen_queue &
-        wasm_screens() {
-            return m_wasmqueue; }
+    // the screens drawn by scripts (Lua, WebAssembly)
+    script_screen_queue &
+        screens() {
+            return m_screenqueue; }
     void
         exit();
     void
@@ -127,7 +127,7 @@ private:
     modeptr_array m_modes { nullptr }; // collection of available application behaviour modes
     mode_stack m_modestack; // current behaviour mode
     python_taskqueue m_taskqueue;
-    wasm_screen_queue m_wasmqueue;
+    script_screen_queue m_screenqueue;
     std::vector<GLFWwindow *> m_windows;
     int m_glfwversion;
 
diff --git a/model/Texture.cpp b/model/Texture.cpp
index e9dc063d..67a33f44 100644
--- a/model/Texture.cpp
+++ b/model/Texture.cpp
@@ -722,8 +722,8 @@ void
 opengl_texture::make_request() {
 
     auto const components { Split( name, '?' ) };
-    if( components.front().ends_with( ".wasm" ) ) {
-        // wasm destination signs are drawn by the vehicles showing them (wasm_screen_queue)
+    if( components.front().ends_with( ".lua" ) || components.front().ends_with( ".wasm" ) ) {
+        // script destination signs are drawn by the vehicles showing them (script_screen_queue)
         return;
     }
 
diff --git a/script_screens_doc.md b/script_screens_doc.md
new file mode 100644
index 00000000..d8a6811b
--- /dev/null
+++ b/script_screens_doc.md
@@ -0,0 +1,199 @@
+# Script screens
+
+Screens drawn by scripts, alongside the Python screens (`pyscreen:`, `pydestinationsign:`): Lua scripts, run by
+LuaJIT, and WebAssembly modules, run by the WAMR interpreter (`ref/wamr`). A script gets the same input a Python
+screen gets (the table in `python_var_doc.md`), returns an RGBA image and, in the cab, may send commands.
+
+A Lua script is text, kept with the vehicles and the `scripts/` folder like the Python screens, and changed with any
+editor. A WebAssembly module is compiled from another language (Rust, C, Zig and the like).
+
+Both run sandboxed: a script reaches only the functions of `eu07` below, and reads files only from its own folder and
+below. A Lua script gets no `io`, `os`, `ffi`, `debug` or `require`, and no precompiled code is loaded.
+
+Unlike a Python screen, which refreshes after a time (`python.updatetime`, `updatetime:`), a script screen refreshes
+every so many rendered frames, set in `eu07.ini`. A call into a script may run at most 200 million instructions
+(Lua runs without the JIT compiler so that the limit holds). A script that fails, or runs over, is switched off, and
+the reason goes to the log.
+
+## eu07.ini
+
+| key                      | default | meaning                                                                        |
+|--------------------------|---------|--------------------------------------------------------------------------------|
+| `luascreens.enabled`     | 1       | 0: no Lua screens; the vehicles show what they did before                      |
+| `wasm.enabled`           | 1       | 0: no WebAssembly screens; the vehicles show what they did before              |
+| `screens.cabframes`      | 4       | a screen in the cab is refreshed every so many frames (1-1000)                 |
+| `screens.externalframes` | 30      | a screen outside the cab (destination sign) is refreshed every so many frames  |
+
+`wasm.cabframes` and `wasm.externalframes`, the first names of the last two, are read as well.
+
+A screen may ask for a longer interval of its own (`frames:` below); the longer of the two counts. Screens sharing
+an interval are spread over its frames, so they don't all refresh on the same one. A screen in the cab is refreshed
+only while the player sits in that cab, a screen outside only while its vehicle is drawn.
+
+## .mmd
+
+In the cab section, next to `pyscreen:`:
+
+```
+luascreen: { ekran.lua target: screen01 frames: 6 parameters: id=1&mode=full }
+wasmscreen: { ekran.wasm target: screen02 }
+```
+
+| key           | meaning                                                                                           |
+|---------------|---------------------------------------------------------------------------------------------------|
+| (first token) | the script, relative to the vehicle folder when it has no path of its own                         |
+| `target:`     | the submodel the screen is drawn on (its texture is replaced); `none` for a screen that only sends commands |
+| `frames:`     | the screen's own refresh interval, used when longer than `screens.cabframes`                      |
+| `parameters:` | extra `key=value` pairs, `&`-separated, added to the input                                        |
+
+A touch on the screen's submodel comes in the input as the list of points `touches`, as for the Python screens.
+
+In `internaldata:`, next to `pydestinationsign:`:
+
+```
+luadestinationsign: { scripts/led_111a20.lua parameters: kod_e=IC&kod_p=TLK&kod_o=R instance: name }
+destinationsignbackground: make:scripts/led_111a20.lua?dummy=1
+```
+
+`luadestinationsign:` and `wasmdestinationsign:` take the keys of `pydestinationsign:` (`instance:`, `parameters:`,
+`background:`) and `frames:`. The input is what a Python sign gets: the timetable (`$timetable`), `_id1` (the
+train), `_id2` (the instance) and the parameters, read anew on every refresh, so the sign can follow the journey. The
+vehicles of one train showing the same request share one screen and one texture. A static destination texture, when
+there is one, still comes first.
+
+A blank sign (`background:`, or the older `destinationsignbackground:`) named `make:<script>.lua?<parameters>` or
+`make:<script>.wasm?<parameters>` is drawn once by that script, with the parameters as its input.
+
+A vehicle may have `pydestinationsign:`, `luadestinationsign:` and `wasmdestinationsign:` side by side. The Lua sign is
+used while the Lua screens are on, else the WebAssembly one while those are on, else the Python one; a release without
+the script screens reads only the Python one. An unknown key in any of the blocks is skipped together with its value.
+
+## The image
+
+`width * height` pixels of 4 bytes, R G B A, in sRGB, row by row from the top, as an image is drawn (PIL's
+`tobytes()` of what a Python screen's `_render` returns). The game turns it bottom row first for the texture, as the
+Python screens' `abstractscreenrenderer` does with `FLIP_TOP_BOTTOM`. Up to 4096 pixels on either side.
+
+## Lua scripts
+
+A script returns a table with `render(state)`, and optionally `init()`, called once after loading. Each screen has its
+own Lua state, so what a script keeps in its variables stays between the refreshes of its screen.
+
+```lua
+local screen = {}
+
+function screen.render(state)
+	local image = eu07.image(256, 128, { 32, 32, 32 })
+	image:fill_rect(0, 0, math.floor(state.velocity * 256 / 160), 128, { 0, 192, 0 })
+	return image -- or nil: nothing changed, the previous image stays
+end
+
+return screen
+```
+
+`state` is a table of the input: numbers, booleans and strings (UTF-8), and `touches`, a list of `{ x, y }`. A
+colour is a table `{ r, g, b }`, each 0-255. Coordinates are in pixels, `(0, 0)` the top left corner.
+
+| function                                   | meaning                                                                       |
+|--------------------------------------------|-------------------------------------------------------------------------------|
+| `eu07.image(width, height [, color])`      | a new image, black or in the colour, up to 4096 on either side                 |
+| `eu07.font(path)`                          | a font of the Python LED screens: `path .. ".png"` and `path .. ".txt"`, as `led_util.load_font()` reads them |
+| `eu07.sprite(path)`                        | a sprite: `path .. ".png"`, as `led_util.load_spr()` reads it                  |
+| `eu07.include(path)`                       | runs another script and returns what it returns (`local util = eu07.include("led_util.lua")`) |
+| `eu07.read_file(path)`                     | the contents of a file, or `nil`                                               |
+| `eu07.time()`                              | seconds of a steady clock shared by all screens, for animations (scrolling) that keep their pace whatever the refresh interval |
+| `eu07.command(name, param1, param2)`       | sends a command (the names of `simulation::commandMap`) to the vehicle of the cab; ignored outside the cab |
+| `eu07.log(...)`, `print(...)`              | writes a line to the log                                                       |
+
+Paths are relative to the script's folder and lead no higher. A character a font lacks is drawn with the font's first
+glyph (`led_util` picks a random one).
+
+| method                                                     | meaning                                                         |
+|------------------------------------------------------------|-----------------------------------------------------------------|
+| `image:width()`, `image:height()`                          | the size                                                        |
+| `image:fill(color)`                                        | fills the image                                                 |
+| `image:set(x, y, color)`, `image:get(x, y)`                | a pixel; `get` returns `r, g, b`                                |
+| `image:fill_rect(x, y, width, height, color)`              | a rectangle, clipped                                            |
+| `image:draw_text(font, x, y, text, color [, spacing])`     | text from `x` rightwards, `spacing` columns between the characters (1); returns the `x` after it (`led_util.draw_str`) |
+| `image:draw_text_right(...)`, `image:draw_text_centered(...)` | the same, ending at `x` or centred on it (`draw_strl`, `draw_strc`) |
+| `image:draw_sprite(sprite, x, y, color)`                   | the lit pixels of the sprite (`draw_spr`)                       |
+| `image:draw_image(image, x, y)`                            | another image, clipped                                          |
+| `image:led_post([bloom])`                                  | `led_util.render_post()`: a new image, each pixel a 2x2 diode with a darker grid, glowing (`bloom`, on by default), in a 1 pixel black frame |
+| `image:resize(width, height)`                              | a new image, scaled as Pillow's `resize(..., Image.LANCZOS)`, with the same pixels |
+| `image:copy()`                                             | a new image, the same                                           |
+| `font:height()`, `font:text_width(text [, spacing])`       | the height, the width of a text (`get_str_len`)                 |
+| `sprite:width()`, `sprite:height()`                        | the size                                                        |
+
+The drawing, `led_post` and `resize` run natively in the game, so a script only says what goes where.
+
+## WebAssembly modules
+
+A module exports:
+
+| export                        | meaning                                                                                  |
+|-------------------------------|------------------------------------------------------------------------------------------|
+| `memory`                      | the linear memory                                                                        |
+| `screen_init() -> i32`        | optional; called once after loading. anything but 0 disables the screen                  |
+| `screen_render() -> i32`      | called on every refresh. returns the address of the image, or 0 to keep the previous one |
+| `screen_width() -> i32`       | the width of the image, asked after every `screen_render` that returned an image         |
+| `screen_height() -> i32`      | the height of the image                                                                  |
+
+Imports, module `eu07` (keys and texts are a pointer and a length in bytes, in the module's memory):
+
+| import                                                          | meaning                                                         |
+|-----------------------------------------------------------------|-----------------------------------------------------------------|
+| `value_type(key, key_len) -> i32`                               | 0 no such value, 1 float, 2 int, 3 bool, 4 string, 5 list of points |
+| `get_float(key, key_len) -> f64`                                | the value as a number (int and bool too); 0 when there is none  |
+| `get_int(key, key_len) -> i32`                                  | the value as an integer (a float is truncated)                   |
+| `get_bool(key, key_len) -> i32`                                 | 1 or 0                                                           |
+| `get_string(key, key_len, buffer, capacity) -> i32`             | copies the text, in UTF-8; returns its whole length, -1 when there is none |
+| `get_vec2_count(key, key_len) -> i32`                           | the number of points in a list (`touches`)                       |
+| `get_vec2(key, key_len, index, out) -> i32`                     | writes the point as two f32 at `out`; returns 1, or 0 when there is none |
+| `command(name, name_len, param1, param2)`                       | sends a command (the names of `simulation::commandMap`) to the vehicle of the cab; ignored outside the cab |
+| `log(text, text_len)`                                           | writes a line to the log                                         |
+| `time() -> f64`                                                 | seconds of a steady clock shared by all screens                  |
+| `led_post(source, width, height, target, bloom) -> i32`         | `led_util.render_post()`, run natively: `target` takes `(2 width + 2) x (2 height + 2)`; `bloom` not 0 for the glow. returns 1, or 0 for sizes over 4096 |
+| `resize_lanczos(source, width, height, target, target_width, target_height) -> i32` | Pillow's `resize(..., Image.LANCZOS)`, run natively, giving the same pixels. returns 1, or 0 for sizes over 4096 |
+| `file_read(path, path_len, buffer, capacity) -> i32`            | reads a file from the module's folder or below; returns the file's whole size, -1 when there is none or the path leads outside |
+
+`led_post` and `resize_lanczos` take RGBA images in the module's memory and write alpha 255; the source and the
+target may overlap. They are what makes LED boards fast enough: in the interpreter the same filters take some 30
+times longer.
+
+The module gets 64 KiB of stack and no heap from the host: it manages its own memory.
+
+### Building a module
+
+With clang (any version with the `wasm32` target), no C library:
+
+```c
+// ekran.c
+#include <stdint.h>
+
+#define IMPORT(name) __attribute__((import_module("eu07"), import_name(name)))
+IMPORT("get_float") double get_float(const char *key, int key_len);
+IMPORT("command") void command(const char *name, int name_len, int param1, int param2);
+
+#define WIDTH 256
+#define HEIGHT 128
+static uint32_t pixels[WIDTH * HEIGHT];
+
+__attribute__((export_name("screen_width"))) int screen_width(void) { return WIDTH; }
+__attribute__((export_name("screen_height"))) int screen_height(void) { return HEIGHT; }
+
+__attribute__((export_name("screen_render"))) int screen_render(void) {
+	double const velocity = get_float("velocity", 8);
+	int const filled = (int)(velocity * WIDTH / 160.0);
+	for (int y = 0; y < HEIGHT; ++y)
+		for (int x = 0; x < WIDTH; ++x)
+			pixels[y * WIDTH + x] = x < filled ? 0xFF00C000u : 0xFF202020u; // A B G R, little-endian
+	return (int)(uintptr_t)pixels;
+}
+```
+
+```
+clang --target=wasm32 -O2 -nostdlib -Wl,--no-entry -o ekran.wasm ekran.c
+```
+
+Any language that compiles to WebAssembly works the same way (Rust `wasm32-unknown-unknown`, Zig, AssemblyScript),
+as long as the module imports nothing but the `eu07` functions above.
diff --git a/scripting/luaprogram.cpp b/scripting/luaprogram.cpp
new file mode 100644
index 00000000..d436cd28
--- /dev/null
+++ b/scripting/luaprogram.cpp
@@ -0,0 +1,847 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+// the Lua screens: scripts run by LuaJIT, each screen in a state of its own, with the eu07 table of
+// script_screens_doc.md. the state has no io, os, ffi, debug or require, reads files only through eu07 and below the
+// script's folder, takes no precompiled code, and runs without the JIT compiler, so that the instruction count hook
+// can stop a script stuck in a loop (LuaJIT calls no hooks in compiled code)
+
+#include "stdafx.h"
+#include "scripting/scriptscreenprogram.h"
+#include "scripting/scriptscreendrawing.h"
+#include "scripting/scriptscreenkernels.h"
+
+#include "utilities/Logs.h"
+#include "utilities/dictionary.h"
+#include "utilities/utilities.h"
+
+#include "stb/stb_image.h"
+
+#include <lua.hpp>
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <format>
+#include <fstream>
+#include <iterator>
+#include <new>
+#include <string_view>
+
+namespace script_screens
+{
+
+namespace
+{
+
+constexpr int hook_interval{1000};
+constexpr char const *image_metatable{"eu07.image"};
+constexpr char const *font_metatable{"eu07.font"};
+constexpr char const *sprite_metatable{"eu07.sprite"};
+// the address is the key of the program in the registry of its state
+constexpr char program_key{0};
+
+class lua_program final : public program
+{
+  public:
+	lua_program(std::string const &Script, script_screen_kind const Kind) : kind{Kind}, script{Script}, folder{substr_path(Script)} {}
+	~lua_program() override
+	{
+		if (m_state != nullptr)
+		{
+			lua_close(m_state);
+		}
+	}
+	lua_program(lua_program const &) = delete;
+	lua_program &operator=(lua_program const &) = delete;
+
+	bool start();
+	bool render(render_call &Call) override;
+
+	script_screen_kind const kind;
+	std::string const script;
+	std::string const folder;
+	render_call *call{nullptr}; // the refresh in progress
+	bool commands_ignored{false}; // a screen outside the cab tried to send a command, and it was logged
+	std::int64_t budget{0}; // instructions left to the call in progress
+
+  private:
+	// calls what's on the stack, with the instruction limit. logs a failure
+	bool run(int Arguments, int Results, std::string_view What);
+	void open_libraries();
+	void register_api();
+
+	lua_State *m_state{nullptr};
+	int m_screen{LUA_NOREF}; // the table the script returned
+};
+
+lua_program *program_of(lua_State *L)
+{
+	lua_pushlightuserdata(L, const_cast<char *>(&program_key)); // NOSONAR: the address is only a key
+	lua_rawget(L, LUA_REGISTRYINDEX);
+	auto *self{static_cast<lua_program *>(lua_touserdata(L, -1))};
+	lua_pop(L, 1);
+	return self;
+}
+
+void count_hook(lua_State *L, lua_Debug * /*Debug*/)
+{
+	auto *self{program_of(L)};
+	if (self == nullptr)
+	{
+		return;
+	}
+	self->budget -= hook_interval;
+	if (self->budget < 0)
+	{
+		luaL_error(L, "instruction limit exceeded");
+	}
+}
+
+// objects of the api -------------------------------------------------------------------------------------------------
+
+template <typename Type_> Type_ *push_object(lua_State *L, Type_ &&Object, char const *Metatable)
+{
+	auto *memory{lua_newuserdata(L, sizeof(Type_))};
+	auto *object{new (memory) Type_(std::move(Object))};
+	luaL_getmetatable(L, Metatable);
+	lua_setmetatable(L, -2);
+	return object;
+}
+
+template <typename Type_> int collect(lua_State *L)
+{
+	static_cast<Type_ *>(lua_touserdata(L, 1))->~Type_();
+	return 0;
+}
+
+// the object at the index when it has the metatable, otherwise nullptr
+template <typename Type_> Type_ *test_object(lua_State *L, int const Index, char const *Metatable)
+{
+	auto *object{lua_touserdata(L, Index)};
+	if (object == nullptr || 0 == lua_getmetatable(L, Index))
+	{
+		return nullptr;
+	}
+	luaL_getmetatable(L, Metatable);
+	auto const matches{lua_rawequal(L, -1, -2) != 0};
+	lua_pop(L, 2);
+	return matches ? static_cast<Type_ *>(object) : nullptr;
+}
+
+template <typename Type_> Type_ &check_object(lua_State *L, int const Index, char const *Metatable)
+{
+	auto *object{test_object<Type_>(L, Index, Metatable)};
+	if (object == nullptr)
+	{
+		luaL_typerror(L, Index, Metatable);
+	}
+	return *object;
+}
+
+canvas &check_image(lua_State *L, int const Index)
+{
+	return check_object<canvas>(L, Index, image_metatable);
+}
+
+int check_int(lua_State *L, int const Index)
+{
+	return static_cast<int>(luaL_checkinteger(L, Index));
+}
+
+int optional_int(lua_State *L, int const Index, int const Default)
+{
+	return static_cast<int>(luaL_optinteger(L, Index, Default));
+}
+
+// a colour: { r, g, b }, each 0-255
+rgb check_color(lua_State *L, int const Index)
+{
+	luaL_checktype(L, Index, LUA_TTABLE);
+	rgb color{};
+	for (int channel = 0; channel < 3; ++channel)
+	{
+		lua_rawgeti(L, Index, channel + 1);
+		if (0 == lua_isnumber(L, -1))
+		{
+			luaL_argerror(L, Index, "a colour is { r, g, b }");
+		}
+		color[channel] = static_cast<std::uint8_t>(std::clamp<lua_Integer>(lua_tointeger(L, -1), 0, 255));
+		lua_pop(L, 1);
+	}
+	return color;
+}
+
+std::string_view check_text(lua_State *L, int const Index)
+{
+	std::size_t length{0};
+	auto const *text{luaL_checklstring(L, Index, &length)};
+	return {text, length};
+}
+
+struct decoded_image
+{
+	std::vector<std::uint8_t> pixels;
+	int width{0};
+	int height{0};
+};
+
+// a .png of the screen's folder or below, as RGBA
+std::optional<decoded_image> read_png(std::string const &Folder, std::string_view const Path)
+{
+	auto const file{read_screen_file(Folder, Path)};
+	if (false == file.has_value())
+	{
+		return std::nullopt;
+	}
+	int width{0};
+	int height{0};
+	int channels{0};
+	// the texture loader turns every image bottom row first, for all threads (model/Texture.cpp): fonts and sprites are
+	// read top row first, as led_util reads them
+	stbi_set_flip_vertically_on_load_thread(0);
+	auto *pixels{stbi_load_from_memory(reinterpret_cast<stbi_uc const *>(file->data()), static_cast<int>(file->size()), &width, &height, &channels, 4)};
+	if (pixels == nullptr)
+	{
+		return std::nullopt;
+	}
+	decoded_image result{std::vector<std::uint8_t>(pixels, pixels + image_size(width, height)), width, height};
+	stbi_image_free(pixels);
+	return result;
+}
+
+// eu07 ---------------------------------------------------------------------------------------------------------------
+
+// eu07.image(width, height [, color]): a new image, black or in the colour
+int api_image(lua_State *L)
+{
+	auto const width{check_int(L, 1)};
+	auto const height{check_int(L, 2)};
+	luaL_argcheck(L, valid_image_side(width), 1, "between 1 and 4096");
+	luaL_argcheck(L, valid_image_side(height), 2, "between 1 and 4096");
+	auto const color{lua_isnoneornil(L, 3) ? rgb{0, 0, 0} : check_color(L, 3)};
+	push_object(L, canvas{width, height, color}, image_metatable);
+	return 1;
+}
+
+// eu07.font(path): the font of path .. ".png" and path .. ".txt", below the script's folder
+int api_font(lua_State *L)
+{
+	auto const path{check_text(L, 1)};
+	auto const *self{program_of(L)};
+	auto loaded{false};
+	{
+		auto const image{read_png(self->folder, std::string{path} + ".png")};
+		auto const description{read_screen_file(self->folder, std::string{path} + ".txt")};
+		if (image.has_value() && description.has_value())
+		{
+			if (auto font{bitmap_font::parse(image->pixels, image->width, image->height, *description)}; font.has_value())
+			{
+				push_object(L, std::move(*font), font_metatable);
+				loaded = true;
+			}
+		}
+	}
+	if (false == loaded)
+	{
+		return luaL_error(L, "font \"%s\" not found below the script's folder", lua_tostring(L, 1));
+	}
+	return 1;
+}
+
+// eu07.sprite(path): the sprite of path .. ".png", below the script's folder
+int api_sprite(lua_State *L)
+{
+	auto const path{check_text(L, 1)};
+	auto const *self{program_of(L)};
+	auto loaded{false};
+	{
+		if (auto const image{read_png(self->folder, std::string{path} + ".png")}; image.has_value())
+		{
+			push_object(L, bitmap_font::sprite(image->pixels, image->width, image->height), sprite_metatable);
+			loaded = true;
+		}
+	}
+	if (false == loaded)
+	{
+		return luaL_error(L, "sprite \"%s\" not found below the script's folder", lua_tostring(L, 1));
+	}
+	return 1;
+}
+
+int api_time(lua_State *L)
+{
+	lua_pushnumber(L, screen_time());
+	return 1;
+}
+
+// eu07.log(...): the values, joined with spaces, as print() does
+int api_log(lua_State *L)
+{
+	auto const count{lua_gettop(L)};
+	for (int idx = 1; idx <= count; ++idx)
+	{
+		if (idx > 1)
+		{
+			lua_pushliteral(L, " ");
+		}
+		lua_getglobal(L, "tostring");
+		lua_pushvalue(L, idx);
+		lua_call(L, 1, 1);
+	}
+	if (count == 0)
+	{
+		lua_pushliteral(L, "");
+	}
+	else
+	{
+		lua_concat(L, count * 2 - 1);
+	}
+	auto const *self{program_of(L)};
+	auto const *text{lua_tostring(L, -1)};
+	WriteLog(std::format("Lua screen \"{}\": {}", self->script, text != nullptr ? text : ""));
+	return 0;
+}
+
+// eu07.command(name, param1, param2): sends a command to the vehicle of the cab
+int api_command(lua_State *L)
+{
+	auto const name{check_text(L, 1)};
+	auto const param1{optional_int(L, 2, 0)};
+	auto const param2{optional_int(L, 3, 0)};
+	auto *self{program_of(L)};
+	if (self->call == nullptr)
+	{
+		return 0;
+	}
+	if (self->kind != script_screen_kind::cab)
+	{
+		if (false == self->commands_ignored)
+		{
+			self->commands_ignored = true;
+			WriteLog(std::format("Lua screen \"{}\": commands are only taken from screens in the cab", self->script));
+		}
+		return 0;
+	}
+	self->call->commands.emplace_back(std::string{name}, param1, param2, self->call->vehicle);
+	return 0;
+}
+
+// eu07.read_file(path): the contents of a file below the script's folder, or nil
+int api_read_file(lua_State *L)
+{
+	auto const path{check_text(L, 1)};
+	auto const *self{program_of(L)};
+	if (auto const contents{read_screen_file(self->folder, path)}; contents.has_value())
+	{
+		lua_pushlstring(L, contents->data(), contents->size());
+	}
+	else
+	{
+		lua_pushnil(L);
+	}
+	return 1;
+}
+
+// loads a script as text: precompiled code is refused. leaves the chunk, or an error message, on the stack
+bool load_chunk(lua_State *L, std::string_view const Code, std::string const &Name)
+{
+	if (false == Code.empty() && Code.front() == '\x1b')
+	{
+		lua_pushfstring(L, "%s: precompiled scripts aren't loaded", Name.c_str());
+		return false;
+	}
+	return 0 == luaL_loadbufferx(L, Code.data(), Code.size(), ("@" + Name).c_str(), "t");
+}
+
+// eu07.include(path): runs another script below the script's folder and returns what it returns
+int api_include(lua_State *L)
+{
+	auto const path{check_text(L, 1)};
+	auto const *self{program_of(L)};
+	auto loaded{false};
+	{
+		if (auto const code{read_screen_file(self->folder, path)}; code.has_value())
+		{
+			loaded = load_chunk(L, *code, self->folder + std::string{path});
+		}
+		else
+		{
+			lua_pushfstring(L, "script \"%s\" not found below the script's folder", lua_tostring(L, 1));
+		}
+	}
+	if (false == loaded)
+	{
+		return lua_error(L);
+	}
+	lua_call(L, 0, 1);
+	return 1;
+}
+
+// eu07.image methods -------------------------------------------------------------------------------------------------
+
+int image_width(lua_State *L)
+{
+	lua_pushinteger(L, check_image(L, 1).width());
+	return 1;
+}
+
+int image_height(lua_State *L)
+{
+	lua_pushinteger(L, check_image(L, 1).height());
+	return 1;
+}
+
+int image_fill(lua_State *L)
+{
+	auto &image{check_image(L, 1)};
+	image.fill(check_color(L, 2));
+	return 0;
+}
+
+int image_set(lua_State *L)
+{
+	auto &image{check_image(L, 1)};
+	auto const x{check_int(L, 2)};
+	auto const y{check_int(L, 3)};
+	image.set(x, y, check_color(L, 4));
+	return 0;
+}
+
+int image_get(lua_State *L)
+{
+	auto const &image{check_image(L, 1)};
+	auto const color{image.get(check_int(L, 2), check_int(L, 3))};
+	for (auto const channel : color)
+	{
+		lua_pushinteger(L, channel);
+	}
+	return 3;
+}
+
+int image_fill_rect(lua_State *L)
+{
+	auto &image{check_image(L, 1)};
+	auto const x{check_int(L, 2)};
+	auto const y{check_int(L, 3)};
+	auto const width{check_int(L, 4)};
+	auto const height{check_int(L, 5)};
+	image.fill_rect(x, y, width, height, check_color(L, 6));
+	return 0;
+}
+
+enum class alignment
+{
+	left,
+	right,
+	center
+};
+
+// image:draw_text(font, x, y, text, color [, spacing]): returns the x after the text
+int draw_text_aligned(lua_State *L, alignment const Alignment)
+{
+	auto &image{check_image(L, 1)};
+	auto const &font{check_object<bitmap_font>(L, 2, font_metatable)};
+	auto x{check_int(L, 3)};
+	auto const y{check_int(L, 4)};
+	auto const text{check_text(L, 5)};
+	auto const color{check_color(L, 6)};
+	auto const spacing{optional_int(L, 7, 1)};
+	if (Alignment == alignment::right)
+	{
+		x -= font.text_width(text, spacing);
+	}
+	else if (Alignment == alignment::center)
+	{
+		x -= font.text_width(text, spacing) / 2;
+	}
+	lua_pushinteger(L, image.draw_text(font, x, y, text, color, spacing));
+	return 1;
+}
+
+int image_draw_text(lua_State *L)
+{
+	return draw_text_aligned(L, alignment::left);
+}
+
+int image_draw_text_right(lua_State *L)
+{
+	return draw_text_aligned(L, alignment::right);
+}
+
+int image_draw_text_centered(lua_State *L)
+{
+	return draw_text_aligned(L, alignment::center);
+}
+
+int image_draw_sprite(lua_State *L)
+{
+	auto &image{check_image(L, 1)};
+	auto const &sprite{check_object<glyph>(L, 2, sprite_metatable)};
+	auto const x{check_int(L, 3)};
+	auto const y{check_int(L, 4)};
+	image.draw_glyph(sprite, x, y, check_color(L, 5));
+	return 0;
+}
+
+int image_draw_image(lua_State *L)
+{
+	auto &image{check_image(L, 1)};
+	auto const &source{check_image(L, 2)};
+	image.draw_image(source, check_int(L, 3), check_int(L, 4));
+	return 0;
+}
+
+// image:led_post([bloom]): led_util's render_post, a new image (2w + 2) x (2h + 2)
+int image_led_post(lua_State *L)
+{
+	auto const &image{check_image(L, 1)};
+	auto const bloom{lua_isnoneornil(L, 2) || lua_toboolean(L, 2) != 0};
+	luaL_argcheck(L, valid_image_side(image.width() * 2 + 2) && valid_image_side(image.height() * 2 + 2), 1, "too large");
+	std::vector<std::uint8_t> pixels(image_size(image.width() * 2 + 2, image.height() * 2 + 2));
+	led_post(image.pixels(), image.width(), image.height(), pixels, bloom);
+	push_object(L, canvas{image.width() * 2 + 2, image.height() * 2 + 2, std::move(pixels)}, image_metatable);
+	return 1;
+}
+
+// image:resize(width, height): scaled as Pillow's resize(..., LANCZOS), a new image
+int image_resize(lua_State *L)
+{
+	auto const &image{check_image(L, 1)};
+	auto const width{check_int(L, 2)};
+	auto const height{check_int(L, 3)};
+	luaL_argcheck(L, valid_image_side(width), 2, "between 1 and 4096");
+	luaL_argcheck(L, valid_image_side(height), 3, "between 1 and 4096");
+	std::vector<std::uint8_t> pixels(image_size(width, height));
+	resize_lanczos(image.pixels(), image.width(), image.height(), pixels, width, height);
+	push_object(L, canvas{width, height, std::move(pixels)}, image_metatable);
+	return 1;
+}
+
+int image_copy(lua_State *L)
+{
+	auto const &image{check_image(L, 1)};
+	push_object(L, canvas{image}, image_metatable);
+	return 1;
+}
+
+// eu07.font and eu07.sprite methods ----------------------------------------------------------------------------------
+
+int font_height(lua_State *L)
+{
+	lua_pushinteger(L, check_object<bitmap_font>(L, 1, font_metatable).height());
+	return 1;
+}
+
+int font_text_width(lua_State *L)
+{
+	auto const &font{check_object<bitmap_font>(L, 1, font_metatable)};
+	auto const text{check_text(L, 2)};
+	lua_pushinteger(L, font.text_width(text, optional_int(L, 3, 1)));
+	return 1;
+}
+
+int sprite_width(lua_State *L)
+{
+	lua_pushinteger(L, check_object<glyph>(L, 1, sprite_metatable).width());
+	return 1;
+}
+
+int sprite_height(lua_State *L)
+{
+	lua_pushinteger(L, check_object<glyph>(L, 1, sprite_metatable).height());
+	return 1;
+}
+
+constexpr std::array image_methods{
+    luaL_Reg{"width", image_width},
+    luaL_Reg{"height", image_height},
+    luaL_Reg{"fill", image_fill},
+    luaL_Reg{"set", image_set},
+    luaL_Reg{"get", image_get},
+    luaL_Reg{"fill_rect", image_fill_rect},
+    luaL_Reg{"draw_text", image_draw_text},
+    luaL_Reg{"draw_text_right", image_draw_text_right},
+    luaL_Reg{"draw_text_centered", image_draw_text_centered},
+    luaL_Reg{"draw_sprite", image_draw_sprite},
+    luaL_Reg{"draw_image", image_draw_image},
+    luaL_Reg{"led_post", image_led_post},
+    luaL_Reg{"resize", image_resize},
+    luaL_Reg{"copy", image_copy},
+    luaL_Reg{nullptr, nullptr},
+};
+
+constexpr std::array font_methods{
+    luaL_Reg{"height", font_height},
+    luaL_Reg{"text_width", font_text_width},
+    luaL_Reg{nullptr, nullptr},
+};
+
+constexpr std::array sprite_methods{
+    luaL_Reg{"width", sprite_width},
+    luaL_Reg{"height", sprite_height},
+    luaL_Reg{nullptr, nullptr},
+};
+
+constexpr std::array api_functions{
+    luaL_Reg{"image", api_image},
+    luaL_Reg{"font", api_font},
+    luaL_Reg{"sprite", api_sprite},
+    luaL_Reg{"time", api_time},
+    luaL_Reg{"log", api_log},
+    luaL_Reg{"command", api_command},
+    luaL_Reg{"read_file", api_read_file},
+    luaL_Reg{"include", api_include},
+    luaL_Reg{nullptr, nullptr},
+};
+
+template <std::size_t Size_> void make_metatable(lua_State *L, char const *Name, std::array<luaL_Reg, Size_> const &Methods, lua_CFunction Collect)
+{
+	luaL_newmetatable(L, Name);
+	lua_newtable(L);
+	for (auto const &method : Methods)
+	{
+		if (method.name == nullptr)
+		{
+			break;
+		}
+		lua_pushcfunction(L, method.func);
+		lua_setfield(L, -2, method.name);
+	}
+	lua_setfield(L, -2, "__index");
+	lua_pushcfunction(L, Collect);
+	lua_setfield(L, -2, "__gc");
+	lua_pop(L, 1);
+}
+
+// the state of a refresh as a table, as the python screens get it in a dictionary; a list of points (touches) is a
+// list of { x, y }
+void push_state(lua_State *L, dictionary_source const &Input)
+{
+	lua_createtable(L, 0, static_cast<int>(Input.floats.size() + Input.integers.size() + Input.bools.size() + Input.strings.size() + Input.vec2_lists.size()));
+	for (auto const &[key, value] : Input.floats)
+	{
+		lua_pushnumber(L, value);
+		lua_setfield(L, -2, key.c_str());
+	}
+	for (auto const &[key, value] : Input.integers)
+	{
+		lua_pushnumber(L, value);
+		lua_setfield(L, -2, key.c_str());
+	}
+	for (auto const &[key, value] : Input.bools)
+	{
+		lua_pushboolean(L, value ? 1 : 0);
+		lua_setfield(L, -2, key.c_str());
+	}
+	for (auto const &[key, value] : Input.strings)
+	{
+		auto const text{utf8_text(value)};
+		lua_pushlstring(L, text.data(), text.size());
+		lua_setfield(L, -2, key.c_str());
+	}
+	for (auto const &[key, points] : Input.vec2_lists)
+	{
+		lua_createtable(L, static_cast<int>(points.size()), 0);
+		for (std::size_t idx = 0; idx < points.size(); ++idx)
+		{
+			lua_createtable(L, 2, 0);
+			lua_pushnumber(L, points[idx].x);
+			lua_rawseti(L, -2, 1);
+			lua_pushnumber(L, points[idx].y);
+			lua_rawseti(L, -2, 2);
+			lua_rawseti(L, -2, static_cast<int>(idx + 1));
+		}
+		lua_setfield(L, -2, key.c_str());
+	}
+}
+
+void open_library(lua_State *L, lua_CFunction Open, char const *Name)
+{
+	lua_pushcfunction(L, Open);
+	lua_pushstring(L, Name);
+	lua_call(L, 1, 0);
+}
+
+void lua_program::open_libraries()
+{
+	open_library(m_state, luaopen_base, "");
+	open_library(m_state, luaopen_table, LUA_TABLIBNAME);
+	open_library(m_state, luaopen_string, LUA_STRLIBNAME);
+	open_library(m_state, luaopen_math, LUA_MATHLIBNAME);
+	open_library(m_state, luaopen_bit, LUA_BITLIBNAME);
+	// what reaches files or loads code
+	for (auto const *name : {"dofile", "loadfile", "load", "loadstring", "module", "require"})
+	{
+		lua_pushnil(m_state);
+		lua_setglobal(m_state, name);
+	}
+	lua_getglobal(m_state, LUA_STRLIBNAME);
+	lua_pushnil(m_state);
+	lua_setfield(m_state, -2, "dump");
+	lua_pop(m_state, 1);
+}
+
+void lua_program::register_api()
+{
+	auto *L{m_state};
+	lua_pushlightuserdata(L, const_cast<char *>(&program_key)); // NOSONAR: the address is only a key
+	lua_pushlightuserdata(L, this);
+	lua_rawset(L, LUA_REGISTRYINDEX);
+
+	make_metatable(L, image_metatable, image_methods, collect<canvas>);
+	make_metatable(L, font_metatable, font_methods, collect<bitmap_font>);
+	make_metatable(L, sprite_metatable, sprite_methods, collect<glyph>);
+
+	lua_newtable(L);
+	for (auto const &function : api_functions)
+	{
+		if (function.name == nullptr)
+		{
+			break;
+		}
+		lua_pushcfunction(L, function.func);
+		lua_setfield(L, -2, function.name);
+	}
+	lua_setglobal(L, "eu07");
+	// print() writes to the log
+	lua_pushcfunction(L, api_log);
+	lua_setglobal(L, "print");
+}
+
+bool lua_program::run(int const Arguments, int const Results, std::string_view const What)
+{
+	budget = instruction_limit;
+	if (0 == lua_pcall(m_state, Arguments, Results, 0))
+	{
+		return true;
+	}
+	auto const *message{lua_tostring(m_state, -1)};
+	ErrorLog(std::format("Lua screen \"{}\": {} failed: {}", script, What, message != nullptr ? message : "unknown error"));
+	lua_pop(m_state, 1);
+	return false;
+}
+
+bool lua_program::start()
+{
+	m_state = luaL_newstate();
+	if (m_state == nullptr)
+	{
+		ErrorLog(std::format("Lua screen \"{}\": failed to create the state", script));
+		return false;
+	}
+	// no compiled code: LuaJIT calls no hooks in it, and the hook is what stops a script stuck in a loop
+	luaJIT_setmode(m_state, 0, LUAJIT_MODE_ENGINE | LUAJIT_MODE_OFF);
+	open_libraries();
+	register_api();
+	lua_sethook(m_state, count_hook, LUA_MASKCOUNT, hook_interval);
+
+	std::ifstream file{script, std::ios::binary};
+	if (false == file.is_open())
+	{
+		ErrorLog(std::format("Lua screen \"{}\": file not found", script));
+		return false;
+	}
+	std::string const code{std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{}};
+	if (false == load_chunk(m_state, code, script))
+	{
+		ErrorLog(std::format("Lua screen \"{}\": {}", script, lua_tostring(m_state, -1)));
+		return false;
+	}
+	if (false == run(0, 1, "the script"))
+	{
+		return false;
+	}
+	if (false == lua_istable(m_state, -1))
+	{
+		ErrorLog(std::format("Lua screen \"{}\": the script has to return a table with a render function", script));
+		return false;
+	}
+	lua_getfield(m_state, -1, "render");
+	auto const renders{lua_isfunction(m_state, -1)};
+	lua_pop(m_state, 1);
+	if (false == renders)
+	{
+		ErrorLog(std::format("Lua screen \"{}\": the script has to return a table with a render function", script));
+		return false;
+	}
+	m_screen = luaL_ref(m_state, LUA_REGISTRYINDEX);
+
+	lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_screen);
+	lua_getfield(m_state, -1, "init");
+	lua_remove(m_state, -2);
+	if (lua_isfunction(m_state, -1))
+	{
+		if (false == run(0, 0, "init"))
+		{
+			return false;
+		}
+	}
+	else
+	{
+		lua_pop(m_state, 1);
+	}
+	WriteLog(std::format("Lua screen \"{}\": ready", script));
+	return true;
+}
+
+bool lua_program::render(render_call &Call)
+{
+	call = &Call;
+	lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_screen);
+	lua_getfield(m_state, -1, "render");
+	lua_remove(m_state, -2);
+	push_state(m_state, Call.input);
+	auto const rendered{run(1, 1, "render")};
+	call = nullptr;
+	if (false == rendered)
+	{
+		return false;
+	}
+	// nil: the screen didn't change, keep the image there is
+	auto succeeded{true};
+	if (auto const *image{test_object<canvas>(m_state, -1, image_metatable)}; image != nullptr)
+	{
+		Call.pixels = image->pixels();
+		Call.width = image->width();
+		Call.height = image->height();
+	}
+	else if (false == lua_isnil(m_state, -1))
+	{
+		ErrorLog(std::format("Lua screen \"{}\": render has to return an image or nil", script));
+		succeeded = false;
+	}
+	lua_pop(m_state, 1);
+	// the images the refreshes left behind
+	lua_gc(m_state, LUA_GCSTEP, 0);
+	return succeeded;
+}
+
+class lua_runtime_host final : public runtime
+{
+  public:
+	std::unique_ptr<program> load(std::string const &Script, script_screen_kind const Kind) override
+	{
+		auto loaded{std::make_unique<lua_program>(Script, Kind)};
+		if (false == loaded->start())
+		{
+			return nullptr;
+		}
+		return loaded;
+	}
+};
+
+} // namespace
+
+std::unique_ptr<runtime> make_lua_runtime()
+{
+	return std::make_unique<lua_runtime_host>();
+}
+
+} // namespace script_screens
diff --git a/scripting/scriptscreendrawing.cpp b/scripting/scriptscreendrawing.cpp
new file mode 100644
index 00000000..f738d929
--- /dev/null
+++ b/scripting/scriptscreendrawing.cpp
@@ -0,0 +1,294 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#include "stdafx.h"
+#include "scripting/scriptscreendrawing.h"
+
+#include <algorithm>
+#include <charconv>
+
+namespace script_screens
+{
+
+namespace
+{
+
+struct sequence
+{
+	std::size_t length{1};
+	char32_t first_bits{0};
+};
+
+// the length of the UTF-8 sequence starting with the byte and the bits it carries; length 0 for a byte that can't
+// start one
+sequence utf8_sequence(std::uint8_t const Lead)
+{
+	if (Lead < 0x80)
+	{
+		return {1, Lead};
+	}
+	if (Lead >= 0xC2 && Lead <= 0xDF)
+	{
+		return {2, static_cast<char32_t>(Lead & 0x1F)};
+	}
+	if (Lead >= 0xE0 && Lead <= 0xEF)
+	{
+		return {3, static_cast<char32_t>(Lead & 0x0F)};
+	}
+	if (Lead >= 0xF0 && Lead <= 0xF4)
+	{
+		return {4, static_cast<char32_t>(Lead & 0x07)};
+	}
+	return {0, 0};
+}
+
+bool continuation(std::uint8_t const Byte)
+{
+	return (Byte & 0xC0) == 0x80;
+}
+
+// a pixel is lit unless it is opaque white, as led_util compares it with (255, 255, 255) and (255, 255, 255, 255)
+bool lit_pixel(std::span<std::uint8_t const> const Rgba, int const Width, int const X, int const Y)
+{
+	auto const at{(static_cast<std::size_t>(Y) * Width + X) * 4};
+	return false == (Rgba[at] == 255 && Rgba[at + 1] == 255 && Rgba[at + 2] == 255 && Rgba[at + 3] == 255);
+}
+
+// the columns [First, First + Count) of the image as a glyph; columns past the image's edge are unlit
+glyph cut_glyph(std::span<std::uint8_t const> const Rgba, int const Width, int const Height, int const First, int const Count)
+{
+	std::vector<bool> lit(static_cast<std::size_t>(Count) * Height, false);
+	for (auto column = 0; column < Count; ++column)
+	{
+		auto const x{First + column};
+		if (x < 0 || x >= Width)
+		{
+			continue;
+		}
+		for (auto y = 0; y < Height; ++y)
+		{
+			lit[static_cast<std::size_t>(column) * Height + y] = lit_pixel(Rgba, Width, x, y);
+		}
+	}
+	return {Count, Height, std::move(lit)};
+}
+
+// the lines of the text, without the line ends (\n or \r\n, as python's text files read them)
+std::vector<std::string_view> lines(std::string_view Text)
+{
+	std::vector<std::string_view> result;
+	while (false == Text.empty())
+	{
+		auto const end{std::min(Text.find('\n'), Text.size())};
+		auto line{Text.substr(0, end)};
+		if (false == line.empty() && line.back() == '\r')
+		{
+			line.remove_suffix(1);
+		}
+		result.push_back(line);
+		Text.remove_prefix(std::min(end + 1, Text.size()));
+	}
+	return result;
+}
+
+} // namespace
+
+std::u32string decode_utf8(std::string_view const Text)
+{
+	std::u32string result;
+	std::size_t idx{0};
+	while (idx < Text.size())
+	{
+		auto const lead{static_cast<std::uint8_t>(Text[idx])};
+		auto [length, code]{utf8_sequence(lead)};
+		auto valid{length > 0 && idx + length <= Text.size()};
+		for (std::size_t offset = 1; valid && offset < length; ++offset)
+		{
+			auto const byte{static_cast<std::uint8_t>(Text[idx + offset])};
+			valid = continuation(byte);
+			code = (code << 6) | (byte & 0x3F);
+		}
+		if (false == valid)
+		{
+			result.push_back(lead);
+			++idx;
+			continue;
+		}
+		result.push_back(code);
+		idx += length;
+	}
+	return result;
+}
+
+std::optional<bitmap_font> bitmap_font::parse(std::span<std::uint8_t const> const Rgba, int const Width, int const Height, std::string_view const Description)
+{
+	if (Width <= 0 || Height <= 0 || Rgba.size() < static_cast<std::size_t>(Width) * Height * 4)
+	{
+		return std::nullopt;
+	}
+	bitmap_font font;
+	font.m_height = Height;
+	auto const all{lines(Description)};
+	auto x{0};
+	// the first line is a comment
+	for (std::size_t line = 1; line < all.size(); ++line)
+	{
+		auto const characters{decode_utf8(all[line])};
+		if (characters.empty())
+		{
+			continue;
+		}
+		// the character, then its width in digits
+		auto const lead{utf8_sequence(static_cast<std::uint8_t>(all[line][0])).length};
+		auto digits{all[line].substr(std::max<std::size_t>(lead, 1))};
+		// int() of python lets spaces around the number through
+		while (false == digits.empty() && (digits.front() == ' ' || digits.front() == '	'))
+		{
+			digits.remove_prefix(1);
+		}
+		while (false == digits.empty() && (digits.back() == ' ' || digits.back() == '	'))
+		{
+			digits.remove_suffix(1);
+		}
+		auto width{0};
+		if (std::from_chars(digits.data(), digits.data() + digits.size(), width).ec != std::errc{} || width < 0)
+		{
+			continue;
+		}
+		auto cut{cut_glyph(Rgba, Width, Height, x, width)};
+		if (font.m_glyphs.empty())
+		{
+			font.m_fallback = cut;
+		}
+		font.m_glyphs.insert_or_assign(characters.front(), std::move(cut));
+		x += width + 1;
+	}
+	if (font.m_glyphs.empty())
+	{
+		return std::nullopt;
+	}
+	return font;
+}
+
+glyph bitmap_font::sprite(std::span<std::uint8_t const> const Rgba, int const Width, int const Height)
+{
+	if (Width <= 0 || Height <= 0 || Rgba.size() < static_cast<std::size_t>(Width) * Height * 4)
+	{
+		return {};
+	}
+	return cut_glyph(Rgba, Width, Height, 0, Width);
+}
+
+glyph const &bitmap_font::find(char32_t const Character) const
+{
+	if (auto const lookup{m_glyphs.find(Character)}; lookup != m_glyphs.end())
+	{
+		return lookup->second;
+	}
+	return m_fallback;
+}
+
+int bitmap_font::text_width(std::string_view const Text, int const Spacing) const
+{
+	auto width{0};
+	for (auto const character : decode_utf8(Text))
+	{
+		width += find(character).width() + Spacing;
+	}
+	return width;
+}
+
+canvas::canvas(int const Width, int const Height, rgb const Color)
+    : m_width{std::max(Width, 0)}, m_height{std::max(Height, 0)}, m_pixels(static_cast<std::size_t>(m_width) * m_height * 4, 255)
+{
+	fill(Color);
+}
+
+canvas::canvas(int const Width, int const Height, std::vector<std::uint8_t> Pixels) : m_width{Width}, m_height{Height}, m_pixels{std::move(Pixels)}
+{
+	m_pixels.resize(static_cast<std::size_t>(std::max(Width, 0)) * std::max(Height, 0) * 4, 255);
+}
+
+void canvas::fill(rgb const Color)
+{
+	for (std::size_t at = 0; at < m_pixels.size(); at += 4)
+	{
+		std::ranges::copy(Color, m_pixels.begin() + static_cast<std::ptrdiff_t>(at));
+		m_pixels[at + 3] = 255;
+	}
+}
+
+void canvas::set(int const X, int const Y, rgb const Color)
+{
+	if (X < 0 || Y < 0 || X >= m_width || Y >= m_height)
+	{
+		return;
+	}
+	auto const at{(static_cast<std::size_t>(Y) * m_width + X) * 4};
+	std::ranges::copy(Color, m_pixels.begin() + static_cast<std::ptrdiff_t>(at));
+}
+
+rgb canvas::get(int const X, int const Y) const
+{
+	if (X < 0 || Y < 0 || X >= m_width || Y >= m_height)
+	{
+		return {0, 0, 0};
+	}
+	auto const at{(static_cast<std::size_t>(Y) * m_width + X) * 4};
+	return {m_pixels[at], m_pixels[at + 1], m_pixels[at + 2]};
+}
+
+void canvas::fill_rect(int const X, int const Y, int const Width, int const Height, rgb const Color)
+{
+	for (auto y = std::max(Y, 0); y < std::min(Y + Height, m_height); ++y)
+	{
+		for (auto x = std::max(X, 0); x < std::min(X + Width, m_width); ++x)
+		{
+			set(x, y, Color);
+		}
+	}
+}
+
+void canvas::draw_glyph(glyph const &Glyph, int const X, int const Y, rgb const Color)
+{
+	for (auto column = 0; column < Glyph.width(); ++column)
+	{
+		for (auto row = 0; row < Glyph.height(); ++row)
+		{
+			if (Glyph.lit(column, row))
+			{
+				set(X + column, Y + row, Color);
+			}
+		}
+	}
+}
+
+int canvas::draw_text(bitmap_font const &Font, int X, int const Y, std::string_view const Text, rgb const Color, int const Spacing)
+{
+	for (auto const character : decode_utf8(Text))
+	{
+		auto const &shape{Font.find(character)};
+		draw_glyph(shape, X, Y, Color);
+		X += shape.width() + Spacing;
+	}
+	return X;
+}
+
+void canvas::draw_image(canvas const &Image, int const X, int const Y)
+{
+	for (auto y = 0; y < Image.height(); ++y)
+	{
+		for (auto x = 0; x < Image.width(); ++x)
+		{
+			set(X + x, Y + y, Image.get(x, y));
+		}
+	}
+}
+
+} // namespace script_screens
diff --git a/scripting/scriptscreendrawing.h b/scripting/scriptscreendrawing.h
new file mode 100644
index 00000000..215f2bf7
--- /dev/null
+++ b/scripting/scriptscreendrawing.h
@@ -0,0 +1,126 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+// the drawing the Lua screens get from the game (eu07.image, eu07.font, eu07.sprite): bitmap fonts and sprites in the
+// format of the python LED screens (scripts/led_util.py: a .png with the glyphs side by side and a .txt with their
+// widths), and RGBA images to draw them on. drawn natively, the script only says what goes where
+
+#include <array>
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace script_screens
+{
+
+using rgb = std::array<std::uint8_t, 3>;
+
+// the code points of UTF-8 text; a byte that doesn't start a valid sequence stands for itself
+std::u32string decode_utf8(std::string_view Text);
+
+// a character or a sprite: its lit pixels, column by column
+class glyph
+{
+  public:
+	glyph() = default;
+	glyph(int Width, int Height, std::vector<bool> Lit) : m_width{Width}, m_height{Height}, m_lit{std::move(Lit)} {}
+
+	int width() const
+	{
+		return m_width;
+	}
+	int height() const
+	{
+		return m_height;
+	}
+	bool lit(int const X, int const Y) const
+	{
+		return m_lit[static_cast<std::size_t>(X) * m_height + Y];
+	}
+
+  private:
+	int m_width{0};
+	int m_height{0};
+	std::vector<bool> m_lit;
+};
+
+class bitmap_font
+{
+  public:
+	// a font as led_util.load_font() reads it: Rgba (Width x Height) has the glyphs side by side, a column apart;
+	// Description has a comment line, then a line per glyph: the character and its width. a pixel is lit unless it is
+	// opaque white. nothing for a description without glyphs
+	static std::optional<bitmap_font> parse(std::span<std::uint8_t const> Rgba, int Width, int Height, std::string_view Description);
+	// a sprite as led_util.load_spr() reads it: the whole image as one glyph
+	static glyph sprite(std::span<std::uint8_t const> Rgba, int Width, int Height);
+
+	int height() const
+	{
+		return m_height;
+	}
+	// the glyph of the character. a character the font lacks gets the font's first glyph (led_util picks a random one;
+	// here every refresh draws the same)
+	glyph const &find(char32_t Character) const;
+	// the width of the text, a column of Spacing after every character (led_util's get_str_len)
+	int text_width(std::string_view Text, int Spacing) const;
+
+  private:
+	int m_height{0};
+	std::unordered_map<char32_t, glyph> m_glyphs;
+	glyph m_fallback;
+};
+
+// an RGBA image, from the top row down
+class canvas
+{
+  public:
+	canvas(int Width, int Height, rgb Color);
+	canvas(int Width, int Height, std::vector<std::uint8_t> Pixels);
+
+	int width() const
+	{
+		return m_width;
+	}
+	int height() const
+	{
+		return m_height;
+	}
+	std::vector<std::uint8_t> const &pixels() const
+	{
+		return m_pixels;
+	}
+
+	void fill(rgb Color);
+	// a pixel outside the image is skipped
+	void set(int X, int Y, rgb Color);
+	// black outside the image
+	rgb get(int X, int Y) const;
+	// clipped to the image
+	void fill_rect(int X, int Y, int Width, int Height, rgb Color);
+	// the lit pixels of the glyph, its top left corner at (X, Y)
+	void draw_glyph(glyph const &Glyph, int X, int Y, rgb Color);
+	// text from X rightwards, Spacing columns between the characters (led_util's draw_str). returns the X after it
+	int draw_text(bitmap_font const &Font, int X, int Y, std::string_view Text, rgb Color, int Spacing);
+	// another image, its top left corner at (X, Y), clipped
+	void draw_image(canvas const &Image, int X, int Y);
+
+  private:
+	int m_width;
+	int m_height;
+	std::vector<std::uint8_t> m_pixels;
+};
+
+} // namespace script_screens
diff --git a/scripting/wasmscreenkernels.cpp b/scripting/scriptscreenkernels.cpp
similarity index 98%
rename from scripting/wasmscreenkernels.cpp
rename to scripting/scriptscreenkernels.cpp
index 4353f189..2bc8e984 100644
--- a/scripting/wasmscreenkernels.cpp
+++ b/scripting/scriptscreenkernels.cpp
@@ -8,7 +8,7 @@ http://mozilla.org/MPL/2.0/.
 */
 
 #include "stdafx.h"
-#include "scripting/wasmscreenkernels.h"
+#include "scripting/scriptscreenkernels.h"
 
 #include <algorithm>
 #include <array>
@@ -16,7 +16,7 @@ http://mozilla.org/MPL/2.0/.
 #include <numbers>
 #include <vector>
 
-namespace wasm_screens
+namespace script_screens
 {
 
 namespace
@@ -239,4 +239,4 @@ bool resize_lanczos(std::span<std::uint8_t const> const Source, int const Width,
 	return true;
 }
 
-} // namespace wasm_screens
+} // namespace script_screens
diff --git a/scripting/wasmscreenkernels.h b/scripting/scriptscreenkernels.h
similarity index 88%
rename from scripting/wasmscreenkernels.h
rename to scripting/scriptscreenkernels.h
index 15400e4b..4a9a265d 100644
--- a/scripting/wasmscreenkernels.h
+++ b/scripting/scriptscreenkernels.h
@@ -12,10 +12,10 @@ http://mozilla.org/MPL/2.0/.
 #include <cstdint>
 #include <span>
 
-// image filters the wasm screens call through the host (eu07.led_post, eu07.resize_lanczos), run natively rather than
+// image filters the script screens call through the host (led_post, resize_lanczos), run natively rather than
 // in the interpreter. they give the very pixels of the Python screens: led_util.render_post() and Pillow's
 // resize(..., Image.LANCZOS). the images are RGBA, 4 bytes a pixel, row by row; alpha is ignored and written as 255
-namespace wasm_screens
+namespace script_screens
 {
 
 // the size in bytes of an RGBA image
@@ -33,4 +33,4 @@ bool led_post(std::span<std::uint8_t const> Source, int Width, int Height, std::
 // for sizes that don't fit the spans
 bool resize_lanczos(std::span<std::uint8_t const> Source, int Width, int Height, std::span<std::uint8_t> Target, int TargetWidth, int TargetHeight);
 
-} // namespace wasm_screens
+} // namespace script_screens
diff --git a/scripting/scriptscreenprogram.h b/scripting/scriptscreenprogram.h
new file mode 100644
index 00000000..af117849
--- /dev/null
+++ b/scripting/scriptscreenprogram.h
@@ -0,0 +1,92 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+// the inside of the script screens: what the queue (scripting/scriptscreens.cpp) asks of a language runtime
+// (scripting/luaprogram.cpp, scripting/wasmprogram.cpp), and the helpers they share
+
+#include "scripting/scriptscreens.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace script_screens
+{
+
+// the largest side of a screen image, in pixels
+constexpr int max_image_side{4096};
+// the most instructions one call into a screen may run, so that a script stuck in a loop can't hang the worker
+constexpr std::int64_t instruction_limit{200'000'000};
+
+struct pending_command
+{
+	std::string name;
+	std::int32_t param1{0};
+	std::int32_t param2{0};
+	std::uint32_t vehicle{0};
+};
+
+// one refresh of a screen: what it gets and what it gives back
+struct render_call
+{
+	dictionary_source const &input;
+	std::uint32_t vehicle{0}; // the target of the commands
+	std::vector<pending_command> commands; // sent during the call
+	// the image drawn, RGBA, from the top row down; empty when the screen didn't change
+	std::vector<std::uint8_t> pixels;
+	int width{0};
+	int height{0};
+};
+
+// a running script: a Lua state, a WebAssembly instance. made, called and destroyed on the worker thread, or by the
+// queue once the worker stopped
+class program
+{
+  public:
+	program() = default;
+	virtual ~program() = default;
+	program(program const &) = delete;
+	program &operator=(program const &) = delete;
+	// runs a refresh. false when the screen can't run (any more); the reason is in the log
+	virtual bool render(render_call &Call) = 0;
+};
+
+// a language: started and stopped with the queue
+class runtime
+{
+  public:
+	runtime() = default;
+	virtual ~runtime() = default;
+	runtime(runtime const &) = delete;
+	runtime &operator=(runtime const &) = delete;
+	// loads the script of a screen and runs its setup. nullptr when it fails; the reason is in the log
+	virtual std::unique_ptr<program> load(std::string const &Script, script_screen_kind Kind) = 0;
+	// called on the worker thread when it starts and before it ends
+	virtual void attach_thread() {}
+	virtual void detach_thread() {}
+};
+
+std::unique_ptr<runtime> make_lua_runtime();
+std::unique_ptr<runtime> make_wasm_runtime();
+
+// the text as UTF-8: names of sceneries and vehicles may come in windows-1250
+std::string utf8_text(std::string const &Text);
+// a file of the screen's folder or below; nothing for a path leading outside, or no such file
+std::optional<std::string> read_screen_file(std::string const &Folder, std::string_view Path);
+// seconds of a steady clock, the same for every screen, for animations that don't depend on how often the screen is
+// refreshed
+double screen_time();
+bool valid_image_side(int Side);
+
+} // namespace script_screens
diff --git a/scripting/wasmscreenrules.cpp b/scripting/scriptscreenrules.cpp
similarity index 96%
rename from scripting/wasmscreenrules.cpp
rename to scripting/scriptscreenrules.cpp
index efd4bf42..58c69efd 100644
--- a/scripting/wasmscreenrules.cpp
+++ b/scripting/scriptscreenrules.cpp
@@ -8,13 +8,13 @@ http://mozilla.org/MPL/2.0/.
 */
 
 #include "stdafx.h"
-#include "scripting/wasmscreenrules.h"
+#include "scripting/scriptscreenrules.h"
 
 #include "utilities/parser.h"
 
 #include <algorithm>
 
-namespace wasm_screens
+namespace script_screens
 {
 
 void screen_config::deserialize(cParser &Input)
@@ -123,4 +123,4 @@ bool is_safe_relative_path(std::string_view const Path)
 	return true;
 }
 
-} // namespace wasm_screens
+} // namespace script_screens
diff --git a/scripting/wasmscreenrules.h b/scripting/scriptscreenrules.h
similarity index 75%
rename from scripting/wasmscreenrules.h
rename to scripting/scriptscreenrules.h
index 923cf926..d7d75384 100644
--- a/scripting/wasmscreenrules.h
+++ b/scripting/scriptscreenrules.h
@@ -15,18 +15,19 @@ http://mozilla.org/MPL/2.0/.
 
 class cParser;
 
-// the parts of the wasm screens that don't need the runtime: the .mmd entries, the frame schedule and the
-// file access rules. kept apart from scripting/wasmscreens.cpp so the unit tests can check them
-namespace wasm_screens
+// the parts of the script screens (Lua, WebAssembly) that don't need a runtime: the .mmd entries, the frame
+// schedule and the file access rules. kept apart from scripting/scriptscreens.cpp so the unit tests can check them
+namespace script_screens
 {
 
-// a wasm screen as the .mmd file describes it:
-//   wasmscreen: { script.wasm target: submodel frames: 4 parameters: key=value&key=value }
-//   wasmdestinationsign: { script.wasm frames: 30 instance: name parameters: ... background: texture }
+// a script screen as the .mmd file describes it:
+//   luascreen: { script.lua target: submodel frames: 4 parameters: key=value&key=value }
+//   luadestinationsign: { script.lua frames: 30 instance: name parameters: ... background: texture }
+// and the same with wasmscreen:, wasmdestinationsign: and a .wasm module
 // every key but the script is optional, and an unknown key is skipped along with its value
 struct screen_config
 {
-	std::string script; // the .wasm file, relative to the vehicle folder when it has no path of its own
+	std::string script; // the .lua script or .wasm module, relative to the vehicle folder when it has no path of its own
 	std::string target{"none"}; // cab screens: the submodel the screen is drawn on
 	std::string parameters; // extra key=value pairs passed to the screen with the simulation state
 	std::string instancing; // destination signs: "name" or "type", one sign per vehicle or per vehicle type
@@ -71,4 +72,4 @@ class frame_schedule
 // drive or a leading separator
 bool is_safe_relative_path(std::string_view Path);
 
-} // namespace wasm_screens
+} // namespace script_screens
diff --git a/scripting/scriptscreens.cpp b/scripting/scriptscreens.cpp
new file mode 100644
index 00000000..53dc7285
--- /dev/null
+++ b/scripting/scriptscreens.cpp
@@ -0,0 +1,511 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#include "stdafx.h"
+#include "scripting/scriptscreens.h"
+#include "scripting/scriptscreenprogram.h"
+#include "scripting/scriptscreenkernels.h"
+
+#include "input/command.h"
+#include "interfaces/ITexture.h"
+#include "utilities/Globals.h"
+#include "utilities/Logs.h"
+#include "utilities/dictionary.h"
+#include "utilities/utilities.h"
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <cstring>
+#include <deque>
+#include <format>
+#include <fstream>
+#include <iterator>
+#include <limits>
+#include <mutex>
+#include <stop_token>
+#include <string_view>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+namespace script_screens
+{
+
+namespace
+{
+
+// the length of the UTF-8 sequence starting with the byte, 0 for a byte that can't start one
+std::size_t utf8_length(std::uint8_t const Lead)
+{
+	if (Lead < 0x80)
+	{
+		return 1;
+	}
+	if (Lead >= 0xC2 && Lead <= 0xDF)
+	{
+		return 2;
+	}
+	if (Lead >= 0xE0 && Lead <= 0xEF)
+	{
+		return 3;
+	}
+	if (Lead >= 0xF0 && Lead <= 0xF4)
+	{
+		return 4;
+	}
+	return 0;
+}
+
+bool is_utf8(std::string_view const Text)
+{
+	std::size_t idx{0};
+	while (idx < Text.size())
+	{
+		auto const length{utf8_length(static_cast<std::uint8_t>(Text[idx]))};
+		if (length == 0 || idx + length > Text.size())
+		{
+			return false;
+		}
+		auto const sequence{Text.substr(idx + 1, length - 1)};
+		if (false == std::ranges::all_of(sequence, [](char const Byte) { return (static_cast<std::uint8_t>(Byte) & 0xC0) == 0x80; }))
+		{
+			return false;
+		}
+		idx += length;
+	}
+	return true;
+}
+
+} // namespace
+
+std::string utf8_text(std::string const &Text)
+{
+	return is_utf8(Text) ? Text : win1250_to_utf8(Text);
+}
+
+std::optional<std::string> read_screen_file(std::string const &Folder, std::string_view const Path)
+{
+	if (false == is_safe_relative_path(Path))
+	{
+		return std::nullopt;
+	}
+	std::ifstream file{Folder + std::string{Path}, std::ios::binary};
+	if (false == file.is_open())
+	{
+		return std::nullopt;
+	}
+	return std::string{std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{}};
+}
+
+double screen_time()
+{
+	static auto const start{std::chrono::steady_clock::now()};
+	return std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+}
+
+bool valid_image_side(int const Side)
+{
+	return Side > 0 && Side <= max_image_side;
+}
+
+} // namespace script_screens
+
+namespace
+{
+
+constexpr std::size_t no_texture{std::numeric_limits<std::size_t>::max()};
+
+std::string_view language_name(script_language const Language)
+{
+	return Language == script_language::lua ? "Lua" : "WASM";
+}
+
+} // namespace
+
+class script_screen
+{
+  public:
+	script_screen(script_screen_queue::screen_request const &Request, script_screens::frame_schedule const &Schedule)
+	    : kind{Request.kind}, language{Request.language}, script{Request.script}, texture{Request.texture}, m_schedule{Schedule}
+	{
+	}
+	~script_screen() = default;
+	script_screen(script_screen const &) = delete;
+	script_screen &operator=(script_screen const &) = delete;
+
+	bool poll(std::uint64_t const Frame)
+	{
+		std::scoped_lock lock{m_schedule_mutex};
+		return m_schedule.poll(Frame);
+	}
+
+	// set when made, read-only afterwards
+	script_screen_kind const kind;
+	script_language const language;
+	std::string const script;
+	ITexture *const texture;
+
+	// set by the worker when the screen can't run (any more); a failed screen isn't refreshed
+	std::atomic<bool> failed{false};
+	// the worker's, and the queue's once the worker stopped
+	std::unique_ptr<script_screens::program> program;
+
+	// the image, handed from the worker to the main thread, bottom row first as the texture takes it
+	std::mutex image_mutex;
+	std::vector<std::uint8_t> image;
+	int image_width{0};
+	int image_height{0};
+	bool image_pending{false}; // drawn and not yet uploaded
+	std::size_t uploaded_texture{no_texture}; // the gl texture the image went to, to upload it again when it's made anew
+
+  private:
+	std::mutex m_schedule_mutex;
+	script_screens::frame_schedule m_schedule;
+};
+
+struct script_screen_queue::implementation
+{
+	struct task
+	{
+		std::shared_ptr<script_screen> screen;
+		std::shared_ptr<dictionary_source> input;
+		std::uint32_t vehicle{0};
+	};
+
+	void run(std::stop_token const &Stop);
+	void process(task const &Task);
+	script_screens::runtime *runtime_of(script_language const Language) const
+	{
+		return Language == script_language::lua ? lua.get() : wasm.get();
+	}
+	static void present(script_screen &Screen, script_screens::render_call &Call);
+	static void upload(script_screen &Screen);
+	static void execute(script_screens::pending_command const &Command);
+
+	std::unique_ptr<script_screens::runtime> lua;
+	std::unique_ptr<script_screens::runtime> wasm;
+	bool initialized{false};
+	std::atomic<std::uint64_t> frame{0};
+
+	std::mutex screens_mutex;
+	std::unordered_map<std::string, std::weak_ptr<script_screen>> screens;
+
+	std::mutex tasks_mutex;
+	std::condition_variable_any tasks_condition;
+	std::deque<task> tasks;
+	std::jthread worker;
+
+	std::mutex commands_mutex;
+	std::vector<script_screens::pending_command> commands;
+};
+
+void script_screen_queue::implementation::run(std::stop_token const &Stop)
+{
+	for (auto *runtime : {lua.get(), wasm.get()})
+	{
+		if (runtime != nullptr)
+		{
+			runtime->attach_thread();
+		}
+	}
+	while (false == Stop.stop_requested())
+	{
+		task next;
+		{
+			std::unique_lock lock{tasks_mutex};
+			if (false == tasks_condition.wait(lock, Stop, [this] { return false == tasks.empty(); }))
+			{
+				break;
+			}
+			next = std::move(tasks.front());
+			tasks.pop_front();
+		}
+		process(next);
+	}
+	for (auto *runtime : {lua.get(), wasm.get()})
+	{
+		if (runtime != nullptr)
+		{
+			runtime->detach_thread();
+		}
+	}
+}
+
+void script_screen_queue::implementation::process(task const &Task)
+{
+	auto &screen{*Task.screen};
+	if (screen.failed)
+	{
+		return;
+	}
+	if (screen.program == nullptr)
+	{
+		auto *runtime{runtime_of(screen.language)};
+		screen.program = runtime != nullptr ? runtime->load(screen.script, screen.kind) : nullptr;
+		if (screen.program == nullptr)
+		{
+			screen.failed = true;
+			return;
+		}
+	}
+
+	script_screens::render_call call{*Task.input, Task.vehicle};
+	if (false == screen.program->render(call))
+	{
+		screen.failed = true;
+		return;
+	}
+	if (false == call.pixels.empty())
+	{
+		if (false == script_screens::valid_image_side(call.width) || false == script_screens::valid_image_side(call.height) ||
+		    call.pixels.size() != script_screens::image_size(call.width, call.height))
+		{
+			ErrorLog(std::format("{} screen \"{}\": invalid image size {}x{}", language_name(screen.language), screen.script, call.width, call.height));
+			screen.failed = true;
+			return;
+		}
+		present(screen, call);
+	}
+	if (false == call.commands.empty())
+	{
+		std::scoped_lock lock{commands_mutex};
+		commands.insert(commands.end(), std::make_move_iterator(call.commands.begin()), std::make_move_iterator(call.commands.end()));
+	}
+}
+
+// keeps the image the screen drew. the script draws from the top row down; the texture takes the bottom row first, as
+// the python screens give it (abstractscreenrenderer flips the image before handing it over)
+void script_screen_queue::implementation::present(script_screen &Screen, script_screens::render_call &Call)
+{
+	auto const row{static_cast<std::size_t>(Call.width) * 4};
+	auto const height{static_cast<std::size_t>(Call.height)};
+	std::scoped_lock lock{Screen.image_mutex};
+	Screen.image.resize(Call.pixels.size());
+	for (std::size_t y = 0; y < height; ++y)
+	{
+		std::memcpy(Screen.image.data() + (height - 1 - y) * row, Call.pixels.data() + y * row, row);
+	}
+	Screen.image_width = Call.width;
+	Screen.image_height = Call.height;
+	Screen.image_pending = true;
+}
+
+void script_screen_queue::implementation::upload(script_screen &Screen)
+{
+	if (Screen.texture == nullptr)
+	{
+		return;
+	}
+	std::scoped_lock lock{Screen.image_mutex};
+	if (Screen.image.empty() || false == Screen.texture->get_is_ready())
+	{
+		// nothing drawn yet, or the texture isn't made yet or was released: the image goes up once it's there
+		return;
+	}
+	if (false == Screen.image_pending && Screen.texture->get_id() == Screen.uploaded_texture)
+	{
+		return;
+	}
+	Screen.texture->update_from_memory(Screen.image_width, Screen.image_height, Screen.image.data());
+	Screen.uploaded_texture = Screen.texture->get_id();
+	Screen.image_pending = false;
+}
+
+void script_screen_queue::implementation::execute(script_screens::pending_command const &Command)
+{
+	auto const lookup{simulation::commandMap.find(Command.name)};
+	if (lookup == simulation::commandMap.end())
+	{
+		ErrorLog(std::format("Script screen: command [{}] not found", Command.name));
+		return;
+	}
+	command_data data{};
+	data.command = lookup->second;
+	data.action = GLFW_PRESS;
+	data.param1 = Command.param1;
+	data.param2 = Command.param2;
+	WriteLog(std::format("Script screen: executing command [{}] with params: P1={} P2={} Target ID={}", Command.name, Command.param1, Command.param2, Command.vehicle));
+	simulation::Commands.push(data, static_cast<std::uint32_t>(command_target::vehicle) | Command.vehicle);
+}
+
+script_screen_queue::script_screen_queue() : m_impl{std::make_unique<implementation>()} {}
+
+script_screen_queue::~script_screen_queue()
+{
+	exit();
+}
+
+bool script_screen_queue::init()
+{
+	if (m_impl->initialized)
+	{
+		return true;
+	}
+	if (Global.luascreens_enabled)
+	{
+		m_impl->lua = script_screens::make_lua_runtime();
+	}
+	if (Global.wasm_enabled)
+	{
+		m_impl->wasm = script_screens::make_wasm_runtime();
+	}
+	if (m_impl->lua == nullptr && m_impl->wasm == nullptr)
+	{
+		return false;
+	}
+	m_impl->initialized = true;
+	auto *impl{m_impl.get()};
+	m_impl->worker = std::jthread([impl](std::stop_token const &Stop) { impl->run(Stop); });
+	WriteLog(std::format("Script screens: setup complete (lua: {}, wasm: {}), refreshed every {} frames in the cab and every {} frames outside", m_impl->lua != nullptr ? "yes" : "no",
+	                     m_impl->wasm != nullptr ? "yes" : "no", Global.screens_cabframes, Global.screens_externalframes));
+	return true;
+}
+
+void script_screen_queue::exit()
+{
+	if (false == m_impl->initialized)
+	{
+		return;
+	}
+	if (m_impl->worker.joinable())
+	{
+		m_impl->worker.request_stop();
+		m_impl->worker.join();
+	}
+	{
+		std::scoped_lock lock{m_impl->tasks_mutex};
+		m_impl->tasks.clear();
+	}
+	{
+		std::scoped_lock lock{m_impl->commands_mutex};
+		m_impl->commands.clear();
+	}
+	{
+		// the vehicles may hold their screens past this point, but the runtimes go now
+		std::scoped_lock lock{m_impl->screens_mutex};
+		for (auto const &[key, screen] : m_impl->screens)
+		{
+			if (auto const live{screen.lock()}; live != nullptr)
+			{
+				live->program.reset();
+				live->failed = true;
+			}
+		}
+		m_impl->screens.clear();
+	}
+	m_impl->lua.reset();
+	m_impl->wasm.reset();
+	m_impl->initialized = false;
+}
+
+bool script_screen_queue::runs(script_language const Language) const
+{
+	return m_impl->initialized && m_impl->runtime_of(Language) != nullptr;
+}
+
+std::shared_ptr<script_screen> script_screen_queue::acquire(screen_request const &Request)
+{
+	if (false == runs(Request.language) || Request.script.empty())
+	{
+		return nullptr;
+	}
+	auto const key{Request.key.empty() ? Request.script : Request.key};
+	std::scoped_lock lock{m_impl->screens_mutex};
+	if (auto const lookup{m_impl->screens.find(key)}; lookup != m_impl->screens.end())
+	{
+		if (auto existing{lookup->second.lock()}; existing != nullptr)
+		{
+			return existing;
+		}
+	}
+	auto const configured{Request.kind == script_screen_kind::cab ? Global.screens_cabframes : Global.screens_externalframes};
+	auto const interval{script_screens::frame_schedule::effective_interval(configured, Request.frames)};
+	auto screen{std::make_shared<script_screen>(Request, script_screens::frame_schedule{m_impl->frame.load(), interval, script_screens::frame_schedule::phase(key, interval)})};
+	m_impl->screens.insert_or_assign(key, screen);
+	WriteLog(std::format("{} screen \"{}\": refreshed every {} frames", language_name(Request.language), Request.script, interval));
+	return screen;
+}
+
+bool script_screen_queue::due(script_screen &Screen) const
+{
+	if (false == m_impl->initialized || Screen.failed)
+	{
+		return false;
+	}
+	return Screen.poll(m_impl->frame.load());
+}
+
+void script_screen_queue::submit(std::shared_ptr<script_screen> const &Screen, std::shared_ptr<dictionary_source> Input, std::uint32_t const Vehicle)
+{
+	if (false == m_impl->initialized || Screen == nullptr || Input == nullptr || Screen->failed)
+	{
+		return;
+	}
+	{
+		std::scoped_lock lock{m_impl->tasks_mutex};
+		auto const pending{std::ranges::find(m_impl->tasks, Screen, &implementation::task::screen)};
+		if (pending != m_impl->tasks.end())
+		{
+			// the refresh still waiting gets the newer input
+			pending->input = std::move(Input);
+			pending->vehicle = Vehicle;
+		}
+		else
+		{
+			m_impl->tasks.emplace_back(Screen, std::move(Input), Vehicle);
+		}
+	}
+	m_impl->tasks_condition.notify_one();
+}
+
+void script_screen_queue::update()
+{
+	if (false == m_impl->initialized)
+	{
+		return;
+	}
+	++m_impl->frame;
+	{
+		std::scoped_lock lock{m_impl->screens_mutex};
+		std::erase_if(m_impl->screens, [](auto const &Entry) { return Entry.second.expired(); });
+		for (auto const &[key, screen] : m_impl->screens)
+		{
+			if (auto const live{screen.lock()}; live != nullptr)
+			{
+				implementation::upload(*live);
+			}
+		}
+	}
+	std::vector<script_screens::pending_command> sent;
+	{
+		std::scoped_lock lock{m_impl->commands_mutex};
+		sent.swap(m_impl->commands);
+	}
+	for (auto const &command : sent)
+	{
+		implementation::execute(command);
+	}
+}
+
+#ifndef WITH_LUA
+std::unique_ptr<script_screens::runtime> script_screens::make_lua_runtime()
+{
+	return nullptr;
+}
+#endif
+
+#ifndef WITH_WASM
+std::unique_ptr<script_screens::runtime> script_screens::make_wasm_runtime()
+{
+	return nullptr;
+}
+#endif
diff --git a/scripting/scriptscreens.h b/scripting/scriptscreens.h
new file mode 100644
index 00000000..fb228581
--- /dev/null
+++ b/scripting/scriptscreens.h
@@ -0,0 +1,98 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+#include "scripting/scriptscreenrules.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+
+struct ITexture;
+struct dictionary_source;
+
+// screens drawn by scripts, the counterpart of the python screens (scripting/PyInt.h): Lua scripts run by LuaJIT
+// (luascreen:, luadestinationsign:) and WebAssembly modules run by WAMR (wasmscreen:, wasmdestinationsign:). a script
+// gets the state a python screen gets, returns an RGBA image and, in the cab, may send commands. the interface is
+// described in script_screens_doc.md.
+// unlike the python screens, which refresh after a time, a script screen refreshes every so many rendered frames:
+// screens.cabframes in eu07.ini for the screens in the cab, screens.externalframes for the screens outside
+// (destination signs)
+
+enum class script_screen_kind
+{
+	cab, // in the cab of the driven vehicle: may send commands to it
+	external // on the outside of a vehicle, such as a destination sign: shows only
+};
+
+enum class script_language
+{
+	lua,
+	wasm
+};
+
+// the language of a script, by its extension: .lua or .wasm
+inline std::optional<script_language> script_language_of(std::string_view const Script)
+{
+	if (Script.ends_with(".lua"))
+	{
+		return script_language::lua;
+	}
+	if (Script.ends_with(".wasm"))
+	{
+		return script_language::wasm;
+	}
+	return std::nullopt;
+}
+
+// one screen: a running script with its own state, and the image it drew last
+class script_screen;
+
+class script_screen_queue
+{
+  public:
+	struct screen_request
+	{
+		script_screen_kind kind{script_screen_kind::cab};
+		script_language language{script_language::lua};
+		std::string script; // the .lua script or .wasm module
+		std::string key; // requests with the same key get the same screen, e.g. the destination signs of one train
+		ITexture *texture{nullptr}; // where the screen is drawn; none for a screen that only sends commands
+		int frames{0}; // the screen's own refresh interval from the .mmd, used when longer than the eu07.ini one
+	};
+
+	script_screen_queue();
+	~script_screen_queue();
+	script_screen_queue(script_screen_queue const &) = delete;
+	script_screen_queue &operator=(script_screen_queue const &) = delete;
+
+	// starts the runtimes switched on in eu07.ini and the worker thread. returns true when any runtime started
+	bool init();
+	// stops the worker and releases every screen, also the ones still held by vehicles
+	void exit();
+	// true when screens in the language can run
+	bool runs(script_language Language) const;
+	// the screen for the request, made on the first request with its key. nullptr when its language doesn't run
+	std::shared_ptr<script_screen> acquire(screen_request const &Request);
+	// true once per refresh interval of the screen. the caller then gathers the screen's input and submit()s it
+	bool due(script_screen &Screen) const;
+	// queues a refresh of the screen with the given input, replacing a refresh of it still waiting.
+	// Vehicle: the vehicle that gets the commands the screen sends; cab screens only
+	void submit(std::shared_ptr<script_screen> const &Screen, std::shared_ptr<dictionary_source> Input, std::uint32_t Vehicle);
+	// main thread, once per rendered frame: uploads the finished images, runs the commands the screens sent and
+	// counts the frame
+	void update();
+
+  private:
+	struct implementation;
+	std::unique_ptr<implementation> m_impl;
+};
diff --git a/scripting/wasmprogram.cpp b/scripting/wasmprogram.cpp
new file mode 100644
index 00000000..d2f914cf
--- /dev/null
+++ b/scripting/wasmprogram.cpp
@@ -0,0 +1,630 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+// the WebAssembly screens: modules run by the WAMR interpreter (ref/wamr), with the "eu07" import module of
+// script_screens_doc.md
+
+#include "stdafx.h"
+#include "scripting/scriptscreenprogram.h"
+#include "scripting/scriptscreenkernels.h"
+
+#include "utilities/Logs.h"
+#include "utilities/dictionary.h"
+#include "utilities/utilities.h"
+
+#include <wasm_export.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstring>
+#include <format>
+#include <fstream>
+#include <iterator>
+#include <limits>
+#include <span>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace script_screens
+{
+
+namespace
+{
+
+// the wasm stack of a screen, in bytes
+constexpr std::uint32_t stack_size{64 * 1024};
+
+// the type of a value in the input of a screen, as eu07.value_type() reports it
+enum class value_type : std::int32_t
+{
+	none = 0,
+	floating = 1,
+	integer = 2,
+	boolean = 3,
+	string = 4,
+	vec2_list = 5
+};
+
+// the input of one refresh, indexed by key. when two values share a key the later one counts, as it does for the
+// python screens, which get the values in the same order
+class input_view
+{
+  public:
+	struct entry
+	{
+		value_type type{value_type::none};
+		std::size_t index{0};
+	};
+
+	explicit input_view(dictionary_source const &Source) : m_source{Source}
+	{
+		index(Source.floats, value_type::floating);
+		index(Source.integers, value_type::integer);
+		index(Source.bools, value_type::boolean);
+		index(Source.strings, value_type::string);
+		index(Source.vec2_lists, value_type::vec2_list);
+	}
+
+	entry find(std::string_view const Key) const
+	{
+		if (auto const lookup{m_entries.find(Key)}; lookup != m_entries.end())
+		{
+			return lookup->second;
+		}
+		return {};
+	}
+
+	dictionary_source const &source() const
+	{
+		return m_source;
+	}
+
+  private:
+	template <typename Sequence_> void index(Sequence_ const &Values, value_type const Type)
+	{
+		for (std::size_t idx = 0; idx < Values.size(); ++idx)
+		{
+			m_entries.insert_or_assign(std::string_view{Values[idx].first}, entry{Type, idx});
+		}
+	}
+
+	dictionary_source const &m_source;
+	std::unordered_map<std::string_view, entry> m_entries;
+};
+
+std::int32_t to_int32(double const Value)
+{
+	if (std::isnan(Value))
+	{
+		return 0;
+	}
+	return static_cast<std::int32_t>(std::clamp(Value, static_cast<double>(std::numeric_limits<std::int32_t>::min()), static_cast<double>(std::numeric_limits<std::int32_t>::max())));
+}
+
+std::int32_t to_int32(std::size_t const Value)
+{
+	return static_cast<std::int32_t>(std::min<std::size_t>(Value, std::numeric_limits<std::int32_t>::max()));
+}
+
+class wasm_program final : public program
+{
+  public:
+	wasm_program(std::string const &Script, script_screen_kind const Kind) : kind{Kind}, script{Script}, folder{substr_path(Script)} {}
+	~wasm_program() override
+	{
+		if (exec_env != nullptr)
+		{
+			wasm_runtime_destroy_exec_env(exec_env);
+		}
+		if (instance != nullptr)
+		{
+			wasm_runtime_deinstantiate(instance);
+		}
+	}
+	wasm_program(wasm_program const &) = delete;
+	wasm_program &operator=(wasm_program const &) = delete;
+
+	bool instantiate(wasm_module_t Module);
+	bool render(render_call &Call) override;
+
+	script_screen_kind const kind;
+	std::string const script;
+	std::string const folder;
+	// the call in progress
+	input_view const *input{nullptr};
+	render_call *call{nullptr};
+	bool commands_ignored{false}; // a screen outside the cab tried to send a command, and it was logged
+
+  private:
+	bool call_i32(wasm_function_inst_t Function, std::string_view Name, std::int32_t &Result);
+	bool present(std::uint32_t Pixels, render_call &Call);
+
+	wasm_module_inst_t instance{nullptr};
+	wasm_exec_env_t exec_env{nullptr};
+	wasm_function_inst_t m_render{nullptr};
+	wasm_function_inst_t m_width{nullptr};
+	wasm_function_inst_t m_height{nullptr};
+};
+
+wasm_program *program_of(wasm_exec_env_t Env)
+{
+	return static_cast<wasm_program *>(wasm_runtime_get_custom_data(wasm_runtime_get_module_inst(Env)));
+}
+
+struct lookup_result
+{
+	input_view const *view{nullptr};
+	input_view::entry entry;
+};
+
+lookup_result lookup(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
+{
+	auto const *screen{program_of(Env)};
+	if (screen == nullptr || screen->input == nullptr || Key == nullptr)
+	{
+		return {};
+	}
+	return {screen->input, screen->input->find(std::string_view{Key, Length})};
+}
+
+// the natives of the "eu07" module, which a screen imports. see script_screens_doc.md
+
+std::int32_t native_value_type(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
+{
+	return static_cast<std::int32_t>(lookup(Env, Key, Length).entry.type);
+}
+
+double native_get_float(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
+{
+	auto const [view, entry]{lookup(Env, Key, Length)};
+	using enum value_type;
+	switch (entry.type)
+	{
+	case floating:
+		return view->source().floats[entry.index].second;
+	case integer:
+		return view->source().integers[entry.index].second;
+	case boolean:
+		return view->source().bools[entry.index].second ? 1.0 : 0.0;
+	default:
+		return 0.0;
+	}
+}
+
+std::int32_t native_get_int(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
+{
+	auto const [view, entry]{lookup(Env, Key, Length)};
+	using enum value_type;
+	switch (entry.type)
+	{
+	case floating:
+		return to_int32(view->source().floats[entry.index].second);
+	case integer:
+		return view->source().integers[entry.index].second;
+	case boolean:
+		return view->source().bools[entry.index].second ? 1 : 0;
+	default:
+		return 0;
+	}
+}
+
+std::int32_t native_get_bool(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
+{
+	auto const [view, entry]{lookup(Env, Key, Length)};
+	using enum value_type;
+	switch (entry.type)
+	{
+	case floating:
+		return view->source().floats[entry.index].second != 0.0 ? 1 : 0;
+	case integer:
+		return view->source().integers[entry.index].second != 0 ? 1 : 0;
+	case boolean:
+		return view->source().bools[entry.index].second ? 1 : 0;
+	default:
+		return 0;
+	}
+}
+
+// copies the string into the buffer, as UTF-8. returns the length of the whole string, which may be more than the
+// buffer took, or -1 when there is no such string
+std::int32_t native_get_string(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length, char *Buffer, std::uint32_t const Capacity)
+{
+	auto const [view, entry]{lookup(Env, Key, Length)};
+	if (entry.type != value_type::string)
+	{
+		return -1;
+	}
+	auto const text{utf8_text(view->source().strings[entry.index].second)};
+	if (Buffer != nullptr)
+	{
+		std::memcpy(Buffer, text.data(), std::min<std::size_t>(text.size(), Capacity));
+	}
+	return to_int32(text.size());
+}
+
+std::int32_t native_get_vec2_count(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
+{
+	auto const [view, entry]{lookup(Env, Key, Length)};
+	if (entry.type != value_type::vec2_list)
+	{
+		return 0;
+	}
+	return to_int32(view->source().vec2_lists[entry.index].second.size());
+}
+
+// writes the point as two f32 at Output. returns 1 on success, 0 when there is no such point
+std::int32_t native_get_vec2(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length, std::int32_t const Index, std::uint32_t const Output)
+{
+	auto const [view, entry]{lookup(Env, Key, Length)};
+	if (entry.type != value_type::vec2_list || Index < 0)
+	{
+		return 0;
+	}
+	auto const &points{view->source().vec2_lists[entry.index].second};
+	if (static_cast<std::size_t>(Index) >= points.size())
+	{
+		return 0;
+	}
+	auto *instance{wasm_runtime_get_module_inst(Env)};
+	std::array<float, 2> const point{points[Index].x, points[Index].y};
+	if (false == wasm_runtime_validate_app_addr(instance, Output, sizeof(point)))
+	{
+		// the runtime has raised an exception, which ends the call
+		return 0;
+	}
+	std::memcpy(wasm_runtime_addr_app_to_native(instance, Output), point.data(), sizeof(point));
+	return 1;
+}
+
+void native_command(wasm_exec_env_t Env, char const *Name, std::uint32_t const Length, std::int32_t const Param1, std::int32_t const Param2)
+{
+	auto *screen{program_of(Env)};
+	if (screen == nullptr || screen->call == nullptr || Name == nullptr)
+	{
+		return;
+	}
+	if (screen->kind != script_screen_kind::cab)
+	{
+		if (false == screen->commands_ignored)
+		{
+			screen->commands_ignored = true;
+			WriteLog(std::format("WASM screen \"{}\": commands are only taken from screens in the cab", screen->script));
+		}
+		return;
+	}
+	screen->call->commands.emplace_back(std::string{Name, Length}, Param1, Param2, screen->call->vehicle);
+}
+
+void native_log(wasm_exec_env_t Env, char const *Text, std::uint32_t const Length)
+{
+	auto const *screen{program_of(Env)};
+	if (screen == nullptr || Text == nullptr)
+	{
+		return;
+	}
+	WriteLog(std::format("WASM screen \"{}\": {}", screen->script, std::string_view{Text, Length}));
+}
+
+// reads a file from the screen's folder into the buffer. returns the size of the whole file, which may be more
+// than the buffer took, or -1 when there is no such file or the path leads outside the folder
+std::int32_t native_file_read(wasm_exec_env_t Env, char const *Path, std::uint32_t const Length, char *Buffer, std::uint32_t const Capacity)
+{
+	auto const *screen{program_of(Env)};
+	if (screen == nullptr || Path == nullptr)
+	{
+		return -1;
+	}
+	auto const contents{read_screen_file(screen->folder, std::string_view{Path, Length})};
+	if (false == contents.has_value())
+	{
+		return -1;
+	}
+	if (Buffer != nullptr)
+	{
+		std::memcpy(Buffer, contents->data(), std::min<std::size_t>(contents->size(), Capacity));
+	}
+	return to_int32(contents->size());
+}
+
+double native_time(wasm_exec_env_t /*Env*/)
+{
+	return screen_time();
+}
+
+// the bytes of an image in the module's memory; an empty span for one that lies outside (the runtime then raises an
+// exception, which ends the call)
+std::span<std::uint8_t> module_image(wasm_exec_env_t Env, std::uint32_t const Offset, int const Width, int const Height)
+{
+	auto *instance{wasm_runtime_get_module_inst(Env)};
+	auto const size{image_size(Width, Height)};
+	if (false == wasm_runtime_validate_app_addr(instance, Offset, size))
+	{
+		return {};
+	}
+	return {static_cast<std::uint8_t *>(wasm_runtime_addr_app_to_native(instance, Offset)), size};
+}
+
+// led_util's render_post, natively: Target takes (2 Width + 2) x (2 Height + 2) pixels. returns 1, or 0 for an image
+// that doesn't fit
+std::int32_t native_led_post(wasm_exec_env_t Env, std::uint32_t const Source, std::int32_t const Width, std::int32_t const Height, std::uint32_t const Target, std::int32_t const Bloom)
+{
+	if (false == valid_image_side(Width) || false == valid_image_side(Height))
+	{
+		return 0;
+	}
+	auto const source{module_image(Env, Source, Width, Height)};
+	auto const target{module_image(Env, Target, Width * 2 + 2, Height * 2 + 2)};
+	if (source.empty() || target.empty())
+	{
+		return 0;
+	}
+	return led_post(source, Width, Height, target, Bloom != 0) ? 1 : 0;
+}
+
+// Pillow's resize(..., LANCZOS), natively. returns 1, or 0 for an image that doesn't fit
+std::int32_t native_resize_lanczos(wasm_exec_env_t Env, std::uint32_t const Source, std::int32_t const Width, std::int32_t const Height, std::uint32_t const Target,
+                                   std::int32_t const TargetWidth, std::int32_t const TargetHeight)
+{
+	if (false == valid_image_side(Width) || false == valid_image_side(Height) || false == valid_image_side(TargetWidth) || false == valid_image_side(TargetHeight))
+	{
+		return 0;
+	}
+	auto const source{module_image(Env, Source, Width, Height)};
+	auto const target{module_image(Env, Target, TargetWidth, TargetHeight)};
+	if (source.empty() || target.empty())
+	{
+		return 0;
+	}
+	return resize_lanczos(source, Width, Height, target, TargetWidth, TargetHeight) ? 1 : 0;
+}
+
+template <typename Function_> NativeSymbol native(char const *Name, Function_ *Function, char const *Signature)
+{
+	return NativeSymbol{Name, reinterpret_cast<void *>(Function), Signature, nullptr};
+}
+
+bool wasm_program::instantiate(wasm_module_t const Module)
+{
+	std::array<char, 256> error{};
+	instance = wasm_runtime_instantiate(Module, stack_size, 0, error.data(), static_cast<std::uint32_t>(error.size()));
+	if (instance == nullptr)
+	{
+		ErrorLog(std::format("WASM screen \"{}\": instantiation failed: {}", script, error.data()));
+		return false;
+	}
+	wasm_runtime_set_custom_data(instance, this);
+	exec_env = wasm_runtime_create_exec_env(instance, stack_size);
+	if (exec_env == nullptr)
+	{
+		ErrorLog(std::format("WASM screen \"{}\": failed to create the execution environment", script));
+		return false;
+	}
+	m_render = wasm_runtime_lookup_function(instance, "screen_render");
+	m_width = wasm_runtime_lookup_function(instance, "screen_width");
+	m_height = wasm_runtime_lookup_function(instance, "screen_height");
+	if (m_render == nullptr || m_width == nullptr || m_height == nullptr)
+	{
+		ErrorLog(std::format("WASM screen \"{}\": the module has to export screen_render, screen_width and screen_height", script));
+		return false;
+	}
+	if (auto *init{wasm_runtime_lookup_function(instance, "screen_init")}; init != nullptr)
+	{
+		std::int32_t result{0};
+		if (false == call_i32(init, "screen_init", result))
+		{
+			return false;
+		}
+		if (result != 0)
+		{
+			ErrorLog(std::format("WASM screen \"{}\": screen_init returned {}", script, result));
+			return false;
+		}
+	}
+	WriteLog(std::format("WASM screen \"{}\": ready", script));
+	return true;
+}
+
+// calls a function of the screen that takes nothing and returns an i32
+bool wasm_program::call_i32(wasm_function_inst_t Function, std::string_view const Name, std::int32_t &Result)
+{
+	wasm_runtime_set_instruction_count_limit(exec_env, static_cast<int>(instruction_limit));
+	std::array<std::uint32_t, 1> cells{};
+	if (false == wasm_runtime_call_wasm(exec_env, Function, 0, cells.data()))
+	{
+		auto const *exception{wasm_runtime_get_exception(instance)};
+		ErrorLog(std::format("WASM screen \"{}\": {} failed: {}", script, Name, exception != nullptr ? exception : "unknown error"));
+		return false;
+	}
+	Result = static_cast<std::int32_t>(cells[0]);
+	return true;
+}
+
+bool wasm_program::render(render_call &Call)
+{
+	input_view const view{Call.input};
+	input = &view;
+	call = &Call;
+	std::int32_t pixels{0};
+	auto const rendered{call_i32(m_render, "screen_render", pixels)};
+	input = nullptr;
+	call = nullptr;
+	if (false == rendered)
+	{
+		return false;
+	}
+	// 0: the screen didn't change, keep the image there is
+	return pixels == 0 || present(static_cast<std::uint32_t>(pixels), Call);
+}
+
+// copies the image the screen drew, Pixels being its address in the module's memory
+bool wasm_program::present(std::uint32_t const Pixels, render_call &Call)
+{
+	std::int32_t width{0};
+	std::int32_t height{0};
+	if (false == call_i32(m_width, "screen_width", width) || false == call_i32(m_height, "screen_height", height))
+	{
+		return false;
+	}
+	if (false == valid_image_side(width) || false == valid_image_side(height))
+	{
+		ErrorLog(std::format("WASM screen \"{}\": invalid image size {}x{}", script, width, height));
+		return false;
+	}
+	auto const size{image_size(width, height)};
+	if (false == wasm_runtime_validate_app_addr(instance, Pixels, size))
+	{
+		ErrorLog(std::format("WASM screen \"{}\": the image lies outside the module's memory", script));
+		return false;
+	}
+	auto const *pixels{static_cast<std::uint8_t const *>(wasm_runtime_addr_app_to_native(instance, Pixels))};
+	Call.pixels.assign(pixels, pixels + size);
+	Call.width = width;
+	Call.height = height;
+	return true;
+}
+
+class wasm_runtime_host final : public runtime
+{
+  public:
+	wasm_runtime_host()
+	    : m_natives{native("value_type", &native_value_type, "(*~)i"),
+	                native("get_float", &native_get_float, "(*~)F"),
+	                native("get_int", &native_get_int, "(*~)i"),
+	                native("get_bool", &native_get_bool, "(*~)i"),
+	                native("get_string", &native_get_string, "(*~*~)i"),
+	                native("get_vec2_count", &native_get_vec2_count, "(*~)i"),
+	                native("get_vec2", &native_get_vec2, "(*~ii)i"),
+	                native("command", &native_command, "(*~ii)"),
+	                native("log", &native_log, "(*~)"),
+	                native("file_read", &native_file_read, "(*~*~)i"),
+	                native("time", &native_time, "()F"),
+	                native("led_post", &native_led_post, "(iiiii)i"),
+	                native("resize_lanczos", &native_resize_lanczos, "(iiiiii)i")}
+	{
+	}
+	~wasm_runtime_host() override
+	{
+		for (auto const &[script, entry] : m_modules)
+		{
+			if (entry.module != nullptr)
+			{
+				wasm_runtime_unload(entry.module);
+			}
+		}
+		if (m_started)
+		{
+			wasm_runtime_destroy();
+		}
+	}
+	wasm_runtime_host(wasm_runtime_host const &) = delete;
+	wasm_runtime_host &operator=(wasm_runtime_host const &) = delete;
+
+	bool start();
+	std::unique_ptr<program> load(std::string const &Script, script_screen_kind Kind) override;
+	void attach_thread() override
+	{
+		wasm_runtime_init_thread_env();
+	}
+	void detach_thread() override
+	{
+		wasm_runtime_destroy_thread_env();
+	}
+
+  private:
+	struct module_entry
+	{
+		std::vector<std::uint8_t> bytes; // the runtime reads the module from here as long as it is loaded
+		wasm_module_t module{nullptr};
+	};
+
+	wasm_module_t load_module(std::string const &Script);
+
+	// the runtime keeps the array and sorts it, so it lives as long as the runtime
+	std::array<NativeSymbol, 13> m_natives;
+	bool m_started{false};
+	std::unordered_map<std::string, module_entry> m_modules; // the worker's
+};
+
+bool wasm_runtime_host::start()
+{
+	RuntimeInitArgs arguments{};
+	arguments.mem_alloc_type = Alloc_With_System_Allocator;
+	arguments.native_module_name = "eu07";
+	arguments.native_symbols = m_natives.data();
+	arguments.n_native_symbols = static_cast<std::uint32_t>(m_natives.size());
+	arguments.running_mode = Mode_Interp;
+	if (false == wasm_runtime_full_init(&arguments))
+	{
+		ErrorLog("WASM screens: failed to initialize the runtime");
+		return false;
+	}
+	wasm_runtime_set_log_level(WASM_LOG_LEVEL_ERROR);
+	m_started = true;
+	return true;
+}
+
+wasm_module_t wasm_runtime_host::load_module(std::string const &Script)
+{
+	if (auto const lookup{m_modules.find(Script)}; lookup != m_modules.end())
+	{
+		return lookup->second.module;
+	}
+	// a failure is kept as well, so the module isn't tried again for every screen using it
+	auto &entry{m_modules[Script]};
+	std::ifstream file{Script, std::ios::binary};
+	if (false == file.is_open())
+	{
+		ErrorLog(std::format("WASM screen \"{}\": file not found", Script));
+		return nullptr;
+	}
+	entry.bytes.assign(std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{});
+	if (entry.bytes.empty() || entry.bytes.size() > std::numeric_limits<std::uint32_t>::max())
+	{
+		ErrorLog(std::format("WASM screen \"{}\": invalid module size", Script));
+		return nullptr;
+	}
+	std::array<char, 256> error{};
+	entry.module = wasm_runtime_load(entry.bytes.data(), static_cast<std::uint32_t>(entry.bytes.size()), error.data(), static_cast<std::uint32_t>(error.size()));
+	if (entry.module == nullptr)
+	{
+		ErrorLog(std::format("WASM screen \"{}\": failed to load the module: {}", Script, error.data()));
+	}
+	return entry.module;
+}
+
+std::unique_ptr<program> wasm_runtime_host::load(std::string const &Script, script_screen_kind const Kind)
+{
+	auto *module{load_module(Script)};
+	if (module == nullptr)
+	{
+		return nullptr;
+	}
+	auto loaded{std::make_unique<wasm_program>(Script, Kind)};
+	if (false == loaded->instantiate(module))
+	{
+		return nullptr;
+	}
+	return loaded;
+}
+
+} // namespace
+
+std::unique_ptr<runtime> make_wasm_runtime()
+{
+	auto started{std::make_unique<wasm_runtime_host>()};
+	if (false == started->start())
+	{
+		return nullptr;
+	}
+	return started;
+}
+
+} // namespace script_screens
diff --git a/scripting/wasmscreens.cpp b/scripting/wasmscreens.cpp
deleted file mode 100644
index 26521435..00000000
--- a/scripting/wasmscreens.cpp
+++ /dev/null
@@ -1,942 +0,0 @@
-/*
-This Source Code Form is subject to the
-terms of the Mozilla Public License, v.
-2.0. If a copy of the MPL was not
-distributed with this file, You can
-obtain one at
-http://mozilla.org/MPL/2.0/.
-*/
-
-#include "stdafx.h"
-#include "scripting/wasmscreens.h"
-#include "scripting/wasmscreenkernels.h"
-
-#include "input/command.h"
-#include "interfaces/ITexture.h"
-#include "utilities/Globals.h"
-#include "utilities/Logs.h"
-#include "utilities/dictionary.h"
-#include "utilities/utilities.h"
-
-#include <wasm_export.h>
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <cmath>
-#include <condition_variable>
-#include <cstring>
-#include <deque>
-#include <format>
-#include <fstream>
-#include <iterator>
-#include <limits>
-#include <mutex>
-#include <span>
-#include <stop_token>
-#include <string_view>
-#include <thread>
-#include <unordered_map>
-#include <vector>
-
-namespace
-{
-
-// the wasm stack of a screen, in bytes
-constexpr std::uint32_t stack_size{64 * 1024};
-// the most instructions one call into a screen may run, so that a screen stuck in a loop can't hang the worker
-constexpr int instruction_limit{200'000'000};
-// the largest side of a screen image, in pixels
-constexpr int max_image_side{4096};
-constexpr std::size_t no_texture{std::numeric_limits<std::size_t>::max()};
-
-// the type of a value in the input of a screen, as eu07.value_type() reports it
-enum class value_type : std::int32_t
-{
-	none = 0,
-	floating = 1,
-	integer = 2,
-	boolean = 3,
-	string = 4,
-	vec2_list = 5
-};
-
-// the input of one refresh, indexed by key. when two values share a key the later one counts, as it does for the
-// python screens, which get the values in the same order
-class input_view
-{
-  public:
-	struct entry
-	{
-		value_type type{value_type::none};
-		std::size_t index{0};
-	};
-
-	explicit input_view(dictionary_source const &Source) : m_source{Source}
-	{
-		index(Source.floats, value_type::floating);
-		index(Source.integers, value_type::integer);
-		index(Source.bools, value_type::boolean);
-		index(Source.strings, value_type::string);
-		index(Source.vec2_lists, value_type::vec2_list);
-	}
-
-	entry find(std::string_view const Key) const
-	{
-		if (auto const lookup{m_entries.find(Key)}; lookup != m_entries.end())
-		{
-			return lookup->second;
-		}
-		return {};
-	}
-
-	dictionary_source const &source() const
-	{
-		return m_source;
-	}
-
-  private:
-	template <typename Sequence_> void index(Sequence_ const &Values, value_type const Type)
-	{
-		for (std::size_t idx = 0; idx < Values.size(); ++idx)
-		{
-			m_entries.insert_or_assign(std::string_view{Values[idx].first}, entry{Type, idx});
-		}
-	}
-
-	dictionary_source const &m_source;
-	std::unordered_map<std::string_view, entry> m_entries;
-};
-
-struct pending_command
-{
-	std::string name;
-	std::int32_t param1{0};
-	std::int32_t param2{0};
-	std::uint32_t vehicle{0};
-};
-
-// the length of the UTF-8 sequence starting with the byte, 0 for a byte that can't start one
-std::size_t utf8_length(std::uint8_t const Lead)
-{
-	if (Lead < 0x80)
-	{
-		return 1;
-	}
-	if (Lead >= 0xC2 && Lead <= 0xDF)
-	{
-		return 2;
-	}
-	if (Lead >= 0xE0 && Lead <= 0xEF)
-	{
-		return 3;
-	}
-	if (Lead >= 0xF0 && Lead <= 0xF4)
-	{
-		return 4;
-	}
-	return 0;
-}
-
-// true for text in valid UTF-8
-bool is_utf8(std::string_view const Text)
-{
-	std::size_t idx{0};
-	while (idx < Text.size())
-	{
-		auto const length{utf8_length(static_cast<std::uint8_t>(Text[idx]))};
-		if (length == 0 || idx + length > Text.size())
-		{
-			return false;
-		}
-		auto const sequence{Text.substr(idx + 1, length - 1)};
-		if (false == std::ranges::all_of(sequence, [](char const Byte) { return (static_cast<std::uint8_t>(Byte) & 0xC0) == 0x80; }))
-		{
-			return false;
-		}
-		idx += length;
-	}
-	return true;
-}
-
-std::int32_t to_int32(double const Value)
-{
-	if (std::isnan(Value))
-	{
-		return 0;
-	}
-	return static_cast<std::int32_t>(std::clamp(Value, static_cast<double>(std::numeric_limits<std::int32_t>::min()), static_cast<double>(std::numeric_limits<std::int32_t>::max())));
-}
-
-std::int32_t to_int32(std::size_t const Value)
-{
-	return static_cast<std::int32_t>(std::min<std::size_t>(Value, std::numeric_limits<std::int32_t>::max()));
-}
-
-} // namespace
-
-class wasm_screen
-{
-  public:
-	wasm_screen(wasm_screen_queue::screen_request const &Request, wasm_screens::frame_schedule const &Schedule)
-	    : kind{Request.kind}, script{Request.script}, folder{substr_path(Request.script)}, texture{Request.texture}, m_schedule{Schedule}
-	{
-	}
-	~wasm_screen()
-	{
-		release_runtime();
-	}
-	wasm_screen(wasm_screen const &) = delete;
-	wasm_screen &operator=(wasm_screen const &) = delete;
-
-	bool poll(std::uint64_t const Frame)
-	{
-		std::scoped_lock lock{m_schedule_mutex};
-		return m_schedule.poll(Frame);
-	}
-
-	// frees the module instance. done by the queue when it stops, as the runtime goes with it
-	void release_runtime()
-	{
-		if (exec_env != nullptr)
-		{
-			wasm_runtime_destroy_exec_env(exec_env);
-			exec_env = nullptr;
-		}
-		if (instance != nullptr)
-		{
-			wasm_runtime_deinstantiate(instance);
-			instance = nullptr;
-		}
-		failed = true;
-	}
-
-	// set when made, read-only afterwards
-	wasm_screen_kind const kind;
-	std::string const script;
-	std::string const folder;
-	ITexture *const texture;
-
-	// set by the worker when the screen can't run (any more); a failed screen isn't refreshed
-	std::atomic<bool> failed{false};
-
-	// the worker's part
-	wasm_module_inst_t instance{nullptr};
-	wasm_exec_env_t exec_env{nullptr};
-	wasm_function_inst_t render{nullptr};
-	wasm_function_inst_t width{nullptr};
-	wasm_function_inst_t height{nullptr};
-	bool commands_ignored{false}; // a screen outside the cab tried to send a command, and it was logged
-	// the call in progress
-	input_view const *input{nullptr};
-	std::vector<pending_command> *commands{nullptr};
-	std::uint32_t vehicle{0};
-
-	// the image, handed from the worker to the main thread
-	std::mutex image_mutex;
-	std::vector<std::uint8_t> image;
-	int image_width{0};
-	int image_height{0};
-	bool image_pending{false}; // drawn and not yet uploaded
-	std::size_t uploaded_texture{no_texture}; // the gl texture the image went to, to upload it again when it's made anew
-
-  private:
-	std::mutex m_schedule_mutex;
-	wasm_screens::frame_schedule m_schedule;
-};
-
-namespace
-{
-
-wasm_screen *screen_of(wasm_exec_env_t Env)
-{
-	return static_cast<wasm_screen *>(wasm_runtime_get_custom_data(wasm_runtime_get_module_inst(Env)));
-}
-
-struct lookup_result
-{
-	input_view const *view{nullptr};
-	input_view::entry entry;
-};
-
-lookup_result lookup(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
-{
-	auto const *screen{screen_of(Env)};
-	if (screen == nullptr || screen->input == nullptr || Key == nullptr)
-	{
-		return {};
-	}
-	return {screen->input, screen->input->find(std::string_view{Key, Length})};
-}
-
-// the natives of the "eu07" module, which a screen imports. see wasm_screens_doc.md
-
-std::int32_t native_value_type(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
-{
-	return static_cast<std::int32_t>(lookup(Env, Key, Length).entry.type);
-}
-
-double native_get_float(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
-{
-	auto const [view, entry]{lookup(Env, Key, Length)};
-	using enum value_type;
-	switch (entry.type)
-	{
-	case floating:
-		return view->source().floats[entry.index].second;
-	case integer:
-		return view->source().integers[entry.index].second;
-	case boolean:
-		return view->source().bools[entry.index].second ? 1.0 : 0.0;
-	default:
-		return 0.0;
-	}
-}
-
-std::int32_t native_get_int(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
-{
-	auto const [view, entry]{lookup(Env, Key, Length)};
-	using enum value_type;
-	switch (entry.type)
-	{
-	case floating:
-		return to_int32(view->source().floats[entry.index].second);
-	case integer:
-		return view->source().integers[entry.index].second;
-	case boolean:
-		return view->source().bools[entry.index].second ? 1 : 0;
-	default:
-		return 0;
-	}
-}
-
-std::int32_t native_get_bool(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
-{
-	auto const [view, entry]{lookup(Env, Key, Length)};
-	using enum value_type;
-	switch (entry.type)
-	{
-	case floating:
-		return view->source().floats[entry.index].second != 0.0 ? 1 : 0;
-	case integer:
-		return view->source().integers[entry.index].second != 0 ? 1 : 0;
-	case boolean:
-		return view->source().bools[entry.index].second ? 1 : 0;
-	default:
-		return 0;
-	}
-}
-
-// copies the string into the buffer, as UTF-8 (names of sceneries and vehicles may be in windows-1250).
-// returns the length of the whole string, which may be more than the buffer took, or -1 when there is no such string
-std::int32_t native_get_string(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length, char *Buffer, std::uint32_t const Capacity)
-{
-	auto const [view, entry]{lookup(Env, Key, Length)};
-	if (entry.type != value_type::string)
-	{
-		return -1;
-	}
-	auto const &value{view->source().strings[entry.index].second};
-	auto const text{is_utf8(value) ? value : win1250_to_utf8(value)};
-	if (Buffer != nullptr)
-	{
-		std::memcpy(Buffer, text.data(), std::min<std::size_t>(text.size(), Capacity));
-	}
-	return to_int32(text.size());
-}
-
-std::int32_t native_get_vec2_count(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length)
-{
-	auto const [view, entry]{lookup(Env, Key, Length)};
-	if (entry.type != value_type::vec2_list)
-	{
-		return 0;
-	}
-	return to_int32(view->source().vec2_lists[entry.index].second.size());
-}
-
-// writes the point as two f32 at Output. returns 1 on success, 0 when there is no such point
-std::int32_t native_get_vec2(wasm_exec_env_t Env, char const *Key, std::uint32_t const Length, std::int32_t const Index, std::uint32_t const Output)
-{
-	auto const [view, entry]{lookup(Env, Key, Length)};
-	if (entry.type != value_type::vec2_list || Index < 0)
-	{
-		return 0;
-	}
-	auto const &points{view->source().vec2_lists[entry.index].second};
-	if (static_cast<std::size_t>(Index) >= points.size())
-	{
-		return 0;
-	}
-	auto *instance{wasm_runtime_get_module_inst(Env)};
-	std::array<float, 2> const point{points[Index].x, points[Index].y};
-	if (false == wasm_runtime_validate_app_addr(instance, Output, sizeof(point)))
-	{
-		// the runtime has raised an exception, which ends the call
-		return 0;
-	}
-	std::memcpy(wasm_runtime_addr_app_to_native(instance, Output), point.data(), sizeof(point));
-	return 1;
-}
-
-void native_command(wasm_exec_env_t Env, char const *Name, std::uint32_t const Length, std::int32_t const Param1, std::int32_t const Param2)
-{
-	auto *screen{screen_of(Env)};
-	if (screen == nullptr || screen->commands == nullptr || Name == nullptr)
-	{
-		return;
-	}
-	if (screen->kind != wasm_screen_kind::cab)
-	{
-		if (false == screen->commands_ignored)
-		{
-			screen->commands_ignored = true;
-			WriteLog(std::format("WASM screen \"{}\": commands are only taken from screens in the cab", screen->script));
-		}
-		return;
-	}
-	screen->commands->emplace_back(std::string{Name, Length}, Param1, Param2, screen->vehicle);
-}
-
-void native_log(wasm_exec_env_t Env, char const *Text, std::uint32_t const Length)
-{
-	auto const *screen{screen_of(Env)};
-	if (screen == nullptr || Text == nullptr)
-	{
-		return;
-	}
-	WriteLog(std::format("WASM screen \"{}\": {}", screen->script, std::string_view{Text, Length}));
-}
-
-// reads a file from the screen's folder into the buffer. returns the size of the whole file, which may be more
-// than the buffer took, or -1 when there is no such file or the path leads outside the folder
-std::int32_t native_file_read(wasm_exec_env_t Env, char const *Path, std::uint32_t const Length, char *Buffer, std::uint32_t const Capacity)
-{
-	auto const *screen{screen_of(Env)};
-	if (screen == nullptr || Path == nullptr)
-	{
-		return -1;
-	}
-	std::string_view const path{Path, Length};
-	if (false == wasm_screens::is_safe_relative_path(path))
-	{
-		return -1;
-	}
-	std::ifstream file{screen->folder + std::string{path}, std::ios::binary | std::ios::ate};
-	if (false == file.is_open())
-	{
-		return -1;
-	}
-	auto const size{static_cast<std::size_t>(std::max<std::streamoff>(file.tellg(), 0))};
-	if (Buffer != nullptr && Capacity > 0)
-	{
-		file.seekg(0);
-		file.read(Buffer, static_cast<std::streamsize>(std::min<std::size_t>(size, Capacity)));
-	}
-	return to_int32(size);
-}
-
-// seconds of a steady clock, the same for every screen, for animations that don't depend on how often the
-// screen is refreshed
-double native_time(wasm_exec_env_t /*Env*/)
-{
-	static auto const start{std::chrono::steady_clock::now()};
-	return std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
-}
-
-// the bytes of an image in the module's memory; an empty span for one that lies outside (the runtime then raises an
-// exception, which ends the call)
-std::span<std::uint8_t> module_image(wasm_exec_env_t Env, std::uint32_t const Offset, int const Width, int const Height)
-{
-	auto *instance{wasm_runtime_get_module_inst(Env)};
-	auto const size{wasm_screens::image_size(Width, Height)};
-	if (false == wasm_runtime_validate_app_addr(instance, Offset, size))
-	{
-		return {};
-	}
-	return {static_cast<std::uint8_t *>(wasm_runtime_addr_app_to_native(instance, Offset)), size};
-}
-
-bool valid_side(std::int32_t const Side)
-{
-	return Side > 0 && Side <= max_image_side;
-}
-
-// led_util's render_post, natively: Target takes (2 Width + 2) x (2 Height + 2) pixels. returns 1, or 0 for an image
-// that doesn't fit
-std::int32_t native_led_post(wasm_exec_env_t Env, std::uint32_t const Source, std::int32_t const Width, std::int32_t const Height, std::uint32_t const Target, std::int32_t const Bloom)
-{
-	if (false == valid_side(Width) || false == valid_side(Height))
-	{
-		return 0;
-	}
-	auto const source{module_image(Env, Source, Width, Height)};
-	auto const target{module_image(Env, Target, Width * 2 + 2, Height * 2 + 2)};
-	if (source.empty() || target.empty())
-	{
-		return 0;
-	}
-	return wasm_screens::led_post(source, Width, Height, target, Bloom != 0) ? 1 : 0;
-}
-
-// Pillow's resize(..., LANCZOS), natively. returns 1, or 0 for an image that doesn't fit
-std::int32_t native_resize_lanczos(wasm_exec_env_t Env, std::uint32_t const Source, std::int32_t const Width, std::int32_t const Height, std::uint32_t const Target,
-                                   std::int32_t const TargetWidth, std::int32_t const TargetHeight)
-{
-	if (false == valid_side(Width) || false == valid_side(Height) || false == valid_side(TargetWidth) || false == valid_side(TargetHeight))
-	{
-		return 0;
-	}
-	auto const source{module_image(Env, Source, Width, Height)};
-	auto const target{module_image(Env, Target, TargetWidth, TargetHeight)};
-	if (source.empty() || target.empty())
-	{
-		return 0;
-	}
-	return wasm_screens::resize_lanczos(source, Width, Height, target, TargetWidth, TargetHeight) ? 1 : 0;
-}
-
-template <typename Function_> NativeSymbol native(char const *Name, Function_ *Function, char const *Signature)
-{
-	return NativeSymbol{Name, reinterpret_cast<void *>(Function), Signature, nullptr};
-}
-
-} // namespace
-
-struct wasm_screen_queue::implementation
-{
-	struct module_entry
-	{
-		std::vector<std::uint8_t> bytes; // the runtime reads the module from here as long as it is loaded
-		wasm_module_t module{nullptr};
-	};
-
-	struct task
-	{
-		std::shared_ptr<wasm_screen> screen;
-		std::shared_ptr<dictionary_source> input;
-		std::uint32_t vehicle{0};
-	};
-
-	implementation()
-	    : natives{native("value_type", &native_value_type, "(*~)i"),
-	              native("get_float", &native_get_float, "(*~)F"),
-	              native("get_int", &native_get_int, "(*~)i"),
-	              native("get_bool", &native_get_bool, "(*~)i"),
-	              native("get_string", &native_get_string, "(*~*~)i"),
-	              native("get_vec2_count", &native_get_vec2_count, "(*~)i"),
-	              native("get_vec2", &native_get_vec2, "(*~ii)i"),
-	              native("command", &native_command, "(*~ii)"),
-	              native("log", &native_log, "(*~)"),
-	              native("file_read", &native_file_read, "(*~*~)i"),
-	              native("time", &native_time, "()F"),
-	              native("led_post", &native_led_post, "(iiiii)i"),
-	              native("resize_lanczos", &native_resize_lanczos, "(iiiiii)i")}
-	{
-	}
-
-	void run(std::stop_token const &Stop);
-	void process(task const &Task);
-	bool instantiate(wasm_screen &Screen);
-	wasm_module_t load_module(std::string const &Script);
-	bool call(wasm_screen &Screen, wasm_function_inst_t Function, std::string_view Name, std::int32_t &Result) const;
-	void present(wasm_screen &Screen, std::uint32_t Pixels) const;
-	static void upload(wasm_screen &Screen);
-	static void execute(pending_command const &Command);
-
-	// the runtime keeps the array and sorts it, so it lives as long as the queue
-	std::array<NativeSymbol, 13> natives;
-	bool initialized{false};
-	std::atomic<std::uint64_t> frame{0};
-
-	std::mutex screens_mutex;
-	std::unordered_map<std::string, std::weak_ptr<wasm_screen>> screens;
-
-	std::mutex tasks_mutex;
-	std::condition_variable_any tasks_condition;
-	std::deque<task> tasks;
-	std::jthread worker;
-
-	std::mutex commands_mutex;
-	std::vector<pending_command> commands;
-
-	// the worker's, and the queue's once the worker stopped
-	std::unordered_map<std::string, module_entry> modules;
-};
-
-void wasm_screen_queue::implementation::run(std::stop_token const &Stop)
-{
-	wasm_runtime_init_thread_env();
-	while (false == Stop.stop_requested())
-	{
-		task next;
-		{
-			std::unique_lock lock{tasks_mutex};
-			if (false == tasks_condition.wait(lock, Stop, [this] { return false == tasks.empty(); }))
-			{
-				break;
-			}
-			next = std::move(tasks.front());
-			tasks.pop_front();
-		}
-		process(next);
-	}
-	wasm_runtime_destroy_thread_env();
-}
-
-void wasm_screen_queue::implementation::process(task const &Task)
-{
-	auto &screen{*Task.screen};
-	if (screen.failed)
-	{
-		return;
-	}
-	if (screen.instance == nullptr && false == instantiate(screen))
-	{
-		screen.failed = true;
-		return;
-	}
-
-	input_view const view{*Task.input};
-	std::vector<pending_command> sent;
-	screen.input = &view;
-	screen.commands = &sent;
-	screen.vehicle = Task.vehicle;
-	std::int32_t pixels{0};
-	auto const rendered{call(screen, screen.render, "screen_render", pixels)};
-	screen.input = nullptr;
-	screen.commands = nullptr;
-	if (false == rendered)
-	{
-		return;
-	}
-	// 0: the screen didn't change, keep the image there is
-	if (pixels != 0)
-	{
-		present(screen, static_cast<std::uint32_t>(pixels));
-	}
-	if (false == sent.empty())
-	{
-		std::scoped_lock lock{commands_mutex};
-		commands.insert(commands.end(), std::make_move_iterator(sent.begin()), std::make_move_iterator(sent.end()));
-	}
-}
-
-bool wasm_screen_queue::implementation::instantiate(wasm_screen &Screen)
-{
-	auto *module{load_module(Screen.script)};
-	if (module == nullptr)
-	{
-		return false;
-	}
-	std::array<char, 256> error{};
-	Screen.instance = wasm_runtime_instantiate(module, stack_size, 0, error.data(), static_cast<std::uint32_t>(error.size()));
-	if (Screen.instance == nullptr)
-	{
-		ErrorLog(std::format("WASM screen \"{}\": instantiation failed: {}", Screen.script, error.data()));
-		return false;
-	}
-	wasm_runtime_set_custom_data(Screen.instance, &Screen);
-	Screen.exec_env = wasm_runtime_create_exec_env(Screen.instance, stack_size);
-	if (Screen.exec_env == nullptr)
-	{
-		ErrorLog(std::format("WASM screen \"{}\": failed to create the execution environment", Screen.script));
-		return false;
-	}
-	Screen.render = wasm_runtime_lookup_function(Screen.instance, "screen_render");
-	Screen.width = wasm_runtime_lookup_function(Screen.instance, "screen_width");
-	Screen.height = wasm_runtime_lookup_function(Screen.instance, "screen_height");
-	if (Screen.render == nullptr || Screen.width == nullptr || Screen.height == nullptr)
-	{
-		ErrorLog(std::format("WASM screen \"{}\": the module has to export screen_render, screen_width and screen_height", Screen.script));
-		return false;
-	}
-	if (auto *init{wasm_runtime_lookup_function(Screen.instance, "screen_init")}; init != nullptr)
-	{
-		std::int32_t result{0};
-		if (false == call(Screen, init, "screen_init", result))
-		{
-			return false;
-		}
-		if (result != 0)
-		{
-			ErrorLog(std::format("WASM screen \"{}\": screen_init returned {}", Screen.script, result));
-			return false;
-		}
-	}
-	WriteLog(std::format("WASM screen \"{}\": ready", Screen.script));
-	return true;
-}
-
-wasm_module_t wasm_screen_queue::implementation::load_module(std::string const &Script)
-{
-	if (auto const lookup{modules.find(Script)}; lookup != modules.end())
-	{
-		return lookup->second.module;
-	}
-	// a failure is kept as well, so the module isn't tried again for every screen using it
-	auto &entry{modules[Script]};
-	std::ifstream file{Script, std::ios::binary};
-	if (false == file.is_open())
-	{
-		ErrorLog(std::format("WASM screen \"{}\": file not found", Script));
-		return nullptr;
-	}
-	entry.bytes.assign(std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{});
-	if (entry.bytes.empty() || entry.bytes.size() > std::numeric_limits<std::uint32_t>::max())
-	{
-		ErrorLog(std::format("WASM screen \"{}\": invalid module size", Script));
-		return nullptr;
-	}
-	std::array<char, 256> error{};
-	entry.module = wasm_runtime_load(entry.bytes.data(), static_cast<std::uint32_t>(entry.bytes.size()), error.data(), static_cast<std::uint32_t>(error.size()));
-	if (entry.module == nullptr)
-	{
-		ErrorLog(std::format("WASM screen \"{}\": failed to load the module: {}", Script, error.data()));
-	}
-	return entry.module;
-}
-
-// calls a function of the screen that takes nothing and returns an i32. a failed call disables the screen
-bool wasm_screen_queue::implementation::call(wasm_screen &Screen, wasm_function_inst_t Function, std::string_view const Name, std::int32_t &Result) const
-{
-	wasm_runtime_set_instruction_count_limit(Screen.exec_env, instruction_limit);
-	std::array<std::uint32_t, 1> cells{};
-	if (false == wasm_runtime_call_wasm(Screen.exec_env, Function, 0, cells.data()))
-	{
-		auto const *exception{wasm_runtime_get_exception(Screen.instance)};
-		ErrorLog(std::format("WASM screen \"{}\": {} failed: {}", Screen.script, Name, exception != nullptr ? exception : "unknown error"));
-		Screen.failed = true;
-		return false;
-	}
-	Result = static_cast<std::int32_t>(cells[0]);
-	return true;
-}
-
-// copies the image the screen drew, Pixels being its address in the module's memory
-void wasm_screen_queue::implementation::present(wasm_screen &Screen, std::uint32_t const Pixels) const
-{
-	std::int32_t width{0};
-	std::int32_t height{0};
-	if (false == call(Screen, Screen.width, "screen_width", width) || false == call(Screen, Screen.height, "screen_height", height))
-	{
-		return;
-	}
-	if (width <= 0 || height <= 0 || width > max_image_side || height > max_image_side)
-	{
-		ErrorLog(std::format("WASM screen \"{}\": invalid image size {}x{}", Screen.script, width, height));
-		Screen.failed = true;
-		return;
-	}
-	auto const size{static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * 4};
-	if (false == wasm_runtime_validate_app_addr(Screen.instance, Pixels, size))
-	{
-		ErrorLog(std::format("WASM screen \"{}\": the image lies outside the module's memory", Screen.script));
-		Screen.failed = true;
-		return;
-	}
-	auto const *pixels{static_cast<std::uint8_t const *>(wasm_runtime_addr_app_to_native(Screen.instance, Pixels))};
-
-	std::scoped_lock lock{Screen.image_mutex};
-	Screen.image.assign(pixels, pixels + size);
-	Screen.image_width = width;
-	Screen.image_height = height;
-	Screen.image_pending = true;
-}
-
-void wasm_screen_queue::implementation::upload(wasm_screen &Screen)
-{
-	if (Screen.texture == nullptr)
-	{
-		return;
-	}
-	std::scoped_lock lock{Screen.image_mutex};
-	if (Screen.image.empty() || false == Screen.texture->get_is_ready())
-	{
-		// nothing drawn yet, or the texture isn't made yet or was released: the image goes up once it's there
-		return;
-	}
-	if (false == Screen.image_pending && Screen.texture->get_id() == Screen.uploaded_texture)
-	{
-		return;
-	}
-	Screen.texture->update_from_memory(Screen.image_width, Screen.image_height, Screen.image.data());
-	Screen.uploaded_texture = Screen.texture->get_id();
-	Screen.image_pending = false;
-}
-
-void wasm_screen_queue::implementation::execute(pending_command const &Command)
-{
-	auto const lookup{simulation::commandMap.find(Command.name)};
-	if (lookup == simulation::commandMap.end())
-	{
-		ErrorLog(std::format("WASM screen: command [{}] not found", Command.name));
-		return;
-	}
-	command_data data{};
-	data.command = lookup->second;
-	data.action = GLFW_PRESS;
-	data.param1 = Command.param1;
-	data.param2 = Command.param2;
-	WriteLog(std::format("WASM screen: executing command [{}] with params: P1={} P2={} Target ID={}", Command.name, Command.param1, Command.param2, Command.vehicle));
-	simulation::Commands.push(data, static_cast<std::uint32_t>(command_target::vehicle) | Command.vehicle);
-}
-
-wasm_screen_queue::wasm_screen_queue() : m_impl{std::make_unique<implementation>()} {}
-
-wasm_screen_queue::~wasm_screen_queue()
-{
-	exit();
-}
-
-bool wasm_screen_queue::init()
-{
-	if (m_impl->initialized)
-	{
-		return true;
-	}
-	RuntimeInitArgs arguments{};
-	arguments.mem_alloc_type = Alloc_With_System_Allocator;
-	arguments.native_module_name = "eu07";
-	arguments.native_symbols = m_impl->natives.data();
-	arguments.n_native_symbols = static_cast<std::uint32_t>(m_impl->natives.size());
-	arguments.running_mode = Mode_Interp;
-	if (false == wasm_runtime_full_init(&arguments))
-	{
-		ErrorLog("WASM screens: failed to initialize the runtime");
-		return false;
-	}
-	wasm_runtime_set_log_level(WASM_LOG_LEVEL_ERROR);
-	m_impl->initialized = true;
-	auto *impl{m_impl.get()};
-	m_impl->worker = std::jthread([impl](std::stop_token const &Stop) { impl->run(Stop); });
-	WriteLog(std::format("WASM screens: setup complete, refreshed every {} frames in the cab and every {} frames outside", Global.wasm_cabframes, Global.wasm_externalframes));
-	return true;
-}
-
-void wasm_screen_queue::exit()
-{
-	if (false == m_impl->initialized)
-	{
-		return;
-	}
-	if (m_impl->worker.joinable())
-	{
-		m_impl->worker.request_stop();
-		m_impl->worker.join();
-	}
-	{
-		std::scoped_lock lock{m_impl->tasks_mutex};
-		m_impl->tasks.clear();
-	}
-	{
-		std::scoped_lock lock{m_impl->commands_mutex};
-		m_impl->commands.clear();
-	}
-	{
-		// the vehicles may hold their screens past this point, but the runtime goes now
-		std::scoped_lock lock{m_impl->screens_mutex};
-		for (auto const &[key, screen] : m_impl->screens)
-		{
-			if (auto const live{screen.lock()}; live != nullptr)
-			{
-				live->release_runtime();
-			}
-		}
-		m_impl->screens.clear();
-	}
-	for (auto const &[script, entry] : m_impl->modules)
-	{
-		if (entry.module != nullptr)
-		{
-			wasm_runtime_unload(entry.module);
-		}
-	}
-	m_impl->modules.clear();
-	wasm_runtime_destroy();
-	m_impl->initialized = false;
-}
-
-std::shared_ptr<wasm_screen> wasm_screen_queue::acquire(screen_request const &Request)
-{
-	if (false == m_impl->initialized || Request.script.empty())
-	{
-		return nullptr;
-	}
-	auto const key{Request.key.empty() ? Request.script : Request.key};
-	std::scoped_lock lock{m_impl->screens_mutex};
-	if (auto const lookup{m_impl->screens.find(key)}; lookup != m_impl->screens.end())
-	{
-		if (auto existing{lookup->second.lock()}; existing != nullptr)
-		{
-			return existing;
-		}
-	}
-	auto const configured{Request.kind == wasm_screen_kind::cab ? Global.wasm_cabframes : Global.wasm_externalframes};
-	auto const interval{wasm_screens::frame_schedule::effective_interval(configured, Request.frames)};
-	auto screen{std::make_shared<wasm_screen>(Request, wasm_screens::frame_schedule{m_impl->frame.load(), interval, wasm_screens::frame_schedule::phase(key, interval)})};
-	m_impl->screens.insert_or_assign(key, screen);
-	return screen;
-}
-
-bool wasm_screen_queue::due(wasm_screen &Screen) const
-{
-	if (false == m_impl->initialized || Screen.failed)
-	{
-		return false;
-	}
-	return Screen.poll(m_impl->frame.load());
-}
-
-void wasm_screen_queue::submit(std::shared_ptr<wasm_screen> const &Screen, std::shared_ptr<dictionary_source> Input, std::uint32_t const Vehicle)
-{
-	if (false == m_impl->initialized || Screen == nullptr || Input == nullptr || Screen->failed)
-	{
-		return;
-	}
-	{
-		std::scoped_lock lock{m_impl->tasks_mutex};
-		auto const pending{std::ranges::find(m_impl->tasks, Screen, &implementation::task::screen)};
-		if (pending != m_impl->tasks.end())
-		{
-			// the refresh still waiting gets the newer input
-			pending->input = std::move(Input);
-			pending->vehicle = Vehicle;
-		}
-		else
-		{
-			m_impl->tasks.emplace_back(Screen, std::move(Input), Vehicle);
-		}
-	}
-	m_impl->tasks_condition.notify_one();
-}
-
-void wasm_screen_queue::update()
-{
-	if (false == m_impl->initialized)
-	{
-		return;
-	}
-	++m_impl->frame;
-	{
-		std::scoped_lock lock{m_impl->screens_mutex};
-		std::erase_if(m_impl->screens, [](auto const &Entry) { return Entry.second.expired(); });
-		for (auto const &[key, screen] : m_impl->screens)
-		{
-			if (auto const live{screen.lock()}; live != nullptr)
-			{
-				implementation::upload(*live);
-			}
-		}
-	}
-	std::vector<pending_command> sent;
-	{
-		std::scoped_lock lock{m_impl->commands_mutex};
-		sent.swap(m_impl->commands);
-	}
-	for (auto const &command : sent)
-	{
-		implementation::execute(command);
-	}
-}
diff --git a/scripting/wasmscreens.h b/scripting/wasmscreens.h
deleted file mode 100644
index a4933646..00000000
--- a/scripting/wasmscreens.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-This Source Code Form is subject to the
-terms of the Mozilla Public License, v.
-2.0. If a copy of the MPL was not
-distributed with this file, You can
-obtain one at
-http://mozilla.org/MPL/2.0/.
-*/
-
-#pragma once
-
-#include "scripting/wasmscreenrules.h"
-
-#include <cstdint>
-#include <memory>
-#include <string>
-
-struct ITexture;
-struct dictionary_source;
-
-// screens drawn by WebAssembly modules, the counterpart of the python screens (scripting/PyInt.h).
-// a module gets the same state the python screens get, returns an RGBA image and may send commands. the
-// interface between the two is described in wasm_screens_doc.md.
-// unlike the python screens, which refresh after a time, a wasm screen refreshes every so many rendered
-// frames: wasm.cabframes in eu07.ini for the screens in the cab, wasm.externalframes for the screens outside
-// (destination signs)
-
-enum class wasm_screen_kind
-{
-	cab, // in the cab of the driven vehicle: may send commands to it
-	external // on the outside of a vehicle, such as a destination sign: shows only
-};
-
-// one screen: a module instance with its own memory, and the image it drew last
-class wasm_screen;
-
-class wasm_screen_queue
-{
-  public:
-	struct screen_request
-	{
-		wasm_screen_kind kind{wasm_screen_kind::cab};
-		std::string script; // the .wasm file
-		std::string key; // requests with the same key get the same screen, e.g. the destination signs of one train
-		ITexture *texture{nullptr}; // where the screen is drawn; none for a screen that only sends commands
-		int frames{0}; // the screen's own refresh interval from the .mmd, used when longer than the eu07.ini one
-	};
-
-	wasm_screen_queue();
-	~wasm_screen_queue();
-	wasm_screen_queue(wasm_screen_queue const &) = delete;
-	wasm_screen_queue &operator=(wasm_screen_queue const &) = delete;
-
-	// starts the runtime and its worker thread. returns true on success
-	bool init();
-	// stops the worker and releases every screen, also the ones still held by vehicles
-	void exit();
-	// the screen for the request, made on the first request with its key. nullptr when the wasm screens are off
-	std::shared_ptr<wasm_screen> acquire(screen_request const &Request);
-	// true once per refresh interval of the screen. the caller then gathers the screen's input and submit()s it
-	bool due(wasm_screen &Screen) const;
-	// queues a refresh of the screen with the given input, replacing a refresh of it still waiting.
-	// Vehicle: the vehicle that gets the commands the screen sends; cab screens only
-	void submit(std::shared_ptr<wasm_screen> const &Screen, std::shared_ptr<dictionary_source> Input, std::uint32_t Vehicle);
-	// main thread, once per rendered frame: uploads the finished images, runs the commands the screens sent and
-	// counts the frame
-	void update();
-
-  private:
-	struct implementation;
-	std::unique_ptr<implementation> m_impl;
-};
diff --git a/scripting/wasmscreensstub.cpp b/scripting/wasmscreensstub.cpp
deleted file mode 100644
index 666b53f2..00000000
--- a/scripting/wasmscreensstub.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-This Source Code Form is subject to the
-terms of the Mozilla Public License, v.
-2.0. If a copy of the MPL was not
-distributed with this file, You can
-obtain one at
-http://mozilla.org/MPL/2.0/.
-*/
-
-// the wasm screens of a build without WITH_WASM: there are none, and the vehicles fall back to what they had before
-
-#include "stdafx.h"
-#include "scripting/wasmscreens.h"
-
-struct wasm_screen_queue::implementation
-{
-};
-
-wasm_screen_queue::wasm_screen_queue() : m_impl{std::make_unique<implementation>()} {}
-
-wasm_screen_queue::~wasm_screen_queue() = default;
-
-bool wasm_screen_queue::init()
-{
-	return false;
-}
-
-void wasm_screen_queue::exit()
-{
-	// nothing was started
-}
-
-std::shared_ptr<wasm_screen> wasm_screen_queue::acquire(screen_request const & /*Request*/)
-{
-	return nullptr;
-}
-
-bool wasm_screen_queue::due(wasm_screen & /*Screen*/) const
-{
-	return false;
-}
-
-void wasm_screen_queue::submit(std::shared_ptr<wasm_screen> const & /*Screen*/, std::shared_ptr<dictionary_source> /*Input*/, std::uint32_t /*Vehicle*/)
-{
-	// nothing to refresh
-}
-
-void wasm_screen_queue::update()
-{
-	// nothing to upload
-}
diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt
index b620cc0a..82c3ffb9 100644
--- a/tests/unit/CMakeLists.txt
+++ b/tests/unit/CMakeLists.txt
@@ -25,9 +25,13 @@ add_executable(${UNIT_TESTS_NAME}
 
 # the core library brings the game's build settings along
 target_link_libraries(${UNIT_TESTS_NAME} PRIVATE eu07_core)
-# the wasm screen host, tested with the real runtime (test_wasm_host.cpp)
+# the script screen host, tested with the real runtimes (test_script_screen_host.cpp)
+target_sources(${UNIT_TESTS_NAME} PRIVATE "${CMAKE_SOURCE_DIR}/scripting/scriptscreens.cpp")
+if (WITH_LUA)
+	target_sources(${UNIT_TESTS_NAME} PRIVATE "${CMAKE_SOURCE_DIR}/scripting/luaprogram.cpp" "${CMAKE_SOURCE_DIR}/stb/stb_image.c")
+endif()
 if (WITH_WASM)
-	target_sources(${UNIT_TESTS_NAME} PRIVATE "${CMAKE_SOURCE_DIR}/scripting/wasmscreens.cpp")
+	target_sources(${UNIT_TESTS_NAME} PRIVATE "${CMAKE_SOURCE_DIR}/scripting/wasmprogram.cpp")
 	target_link_libraries(${UNIT_TESTS_NAME} PRIVATE eu07_wamr)
 endif()
 target_include_directories(${UNIT_TESTS_NAME} PRIVATE "${DEPS_DIR}/doctest")
@@ -39,6 +43,10 @@ endif()
 set_target_properties(${UNIT_TESTS_NAME} PROPERTIES FOLDER "tests")
 
 add_test(NAME ${UNIT_TESTS_NAME} COMMAND ${UNIT_TESTS_NAME})
+if (WIN32)
+	# the libraries of the game (lua51.dll) are next to the game, see run_tests.cmake
+	set_tests_properties(${UNIT_TESTS_NAME} PROPERTIES ENVIRONMENT_MODIFICATION "PATH=path_list_prepend:$<TARGET_FILE_DIR:eu07>")
+endif()
 
 # for running the tests at the end of building the game, see the main CMakeLists.txt
 set(UNIT_TEST_DATA ${UNIT_TEST_DATA} PARENT_SCOPE)
diff --git a/tests/unit/run_tests.cmake b/tests/unit/run_tests.cmake
index 6cf6f508..71acfb25 100644
--- a/tests/unit/run_tests.cmake
+++ b/tests/unit/run_tests.cmake
@@ -2,6 +2,14 @@
 # prints a one line summary when they pass, the full report when they don't. a failure fails the build and
 # removes the game binary, so the next build links it again and reruns the tests
 
+# the tests load the libraries the game loads (lua51.dll for the Lua screens): on Windows they're looked for next to
+# the game binary as well, where they are for running the game, since nothing puts them next to the tests
+if(CMAKE_HOST_WIN32)
+	get_filename_component(game_folder "${GAME}" DIRECTORY)
+	file(TO_NATIVE_PATH "${game_folder}" game_folder)
+	set(ENV{PATH} "${game_folder};$ENV{PATH}")
+endif()
+
 execute_process(
 	COMMAND "${TESTS}" --no-intro --no-version
 	RESULT_VARIABLE result
diff --git a/tests/unit/test_script_screen_drawing.cpp b/tests/unit/test_script_screen_drawing.cpp
new file mode 100644
index 00000000..ff822b02
--- /dev/null
+++ b/tests/unit/test_script_screen_drawing.cpp
@@ -0,0 +1,120 @@
+#include "stdafx.h"
+#include "doctest.h"
+
+#include "scripting/scriptscreendrawing.h"
+
+#include <algorithm>
+#include <array>
+#include <vector>
+
+// the drawing the Lua screens get from the game: fonts read as scripts/led_util.py reads them, text and images
+
+using script_screens::bitmap_font;
+using script_screens::canvas;
+using script_screens::rgb;
+
+namespace {
+
+// an RGBA image Width x Height, white, with the listed pixels set to the colour
+std::vector<std::uint8_t> image(int const Width, int const Height, std::vector<std::pair<int, int>> const &Pixels,
+                                std::array<std::uint8_t, 4> const Color = {0, 0, 0, 255}) {
+	std::vector<std::uint8_t> pixels(static_cast<std::size_t>(Width) * Height * 4, 255);
+	for (auto const &[x, y] : Pixels) {
+		std::copy(Color.begin(), Color.end(), pixels.begin() + (static_cast<std::ptrdiff_t>(y) * Width + x) * 4);
+	}
+	return pixels;
+}
+
+} // namespace
+
+TEST_CASE("script screen drawing: UTF-8 text becomes code points, a stray byte stands for itself") {
+	CHECK(script_screens::decode_utf8("ab") == U"ab");
+	CHECK(script_screens::decode_utf8("\xc5\x81\xc3\xb3\xc5\xbc") == U"Łóż"); // Łóż
+	CHECK(script_screens::decode_utf8("a\xb3z") == U"a³z");
+	CHECK(script_screens::decode_utf8("\xe2\x82") == U"â\u0082");
+}
+
+TEST_CASE("script screen drawing: a font as led_util reads it, glyphs a column apart") {
+	// "a" 2 wide (x 0-1), "Ł" 1 wide (x 3), " " 1 wide (x 5)
+	auto const pixels{image(6, 2, {{0, 0}, {1, 1}, {3, 0}, {3, 1}})};
+	auto const font{bitmap_font::parse(pixels, 6, 2, "// comment\r\na2\r\n\xc5\x81" "1\r\n 1\r\n")};
+	REQUIRE(font.has_value());
+	CHECK(font->height() == 2);
+
+	auto const &a{font->find(U'a')};
+	REQUIRE(a.width() == 2);
+	CHECK(a.lit(0, 0));
+	CHECK_FALSE(a.lit(0, 1));
+	CHECK(a.lit(1, 1));
+
+	auto const &l{font->find(U'Ł')};
+	REQUIRE(l.width() == 1);
+	CHECK(l.lit(0, 0));
+	CHECK(l.lit(0, 1));
+
+	auto const &space{font->find(U' ')};
+	REQUIRE(space.width() == 1);
+	CHECK_FALSE(space.lit(0, 0));
+
+	// a character the font lacks: its first glyph
+	CHECK(font->find(U'q').width() == 2);
+	// led_util's get_str_len: a spacing column after every character
+	CHECK(font->text_width("a\xc5\x81", 1) == 5);
+	CHECK(font->text_width("", 1) == 0);
+}
+
+TEST_CASE("script screen drawing: a pixel is lit unless it is opaque white") {
+	auto pixels{image(3, 1, {{0, 0}})};
+	// transparent white: lit, as led_util compares the whole pixel with (255, 255, 255, 255)
+	pixels[1 * 4 + 3] = 0;
+	auto const sprite{bitmap_font::sprite(pixels, 3, 1)};
+	REQUIRE(sprite.width() == 3);
+	CHECK(sprite.lit(0, 0));
+	CHECK(sprite.lit(1, 0));
+	CHECK_FALSE(sprite.lit(2, 0));
+}
+
+TEST_CASE("script screen drawing: a description without glyphs, or one wider than its image, does no harm") {
+	auto const pixels{image(2, 1, {})};
+	CHECK_FALSE(bitmap_font::parse(pixels, 2, 1, "// only a comment\n").has_value());
+	CHECK_FALSE(bitmap_font::parse(pixels, 2, 1, "").has_value());
+	// the glyph runs past the image: the columns past its edge are unlit
+	auto const font{bitmap_font::parse(pixels, 2, 1, "//\nw5\n")};
+	REQUIRE(font.has_value());
+	CHECK(font->find(U'w').width() == 5);
+	CHECK_FALSE(font->find(U'w').lit(4, 0));
+}
+
+TEST_CASE("script screen drawing: text is drawn from x rightwards and returns where it ends") {
+	auto const pixels{image(4, 1, {{0, 0}, {1, 0}, {3, 0}})};
+	auto const font{bitmap_font::parse(pixels, 4, 1, "//\na2\nb1\n")};
+	REQUIRE(font.has_value());
+	canvas board{8, 1, rgb{0, 0, 0}};
+	auto const end{board.draw_text(*font, 1, 0, "ab", rgb{9, 8, 7}, 1)};
+	CHECK(end == 6);
+	CHECK(board.get(0, 0) == rgb{0, 0, 0});
+	CHECK(board.get(1, 0) == rgb{9, 8, 7});
+	CHECK(board.get(2, 0) == rgb{9, 8, 7});
+	CHECK(board.get(3, 0) == rgb{0, 0, 0});
+	CHECK(board.get(4, 0) == rgb{9, 8, 7});
+	// partly off the image: clipped
+	canvas narrow{2, 1, rgb{0, 0, 0}};
+	narrow.draw_text(*font, -1, 0, "ab", rgb{1, 1, 1}, 1);
+	CHECK(narrow.get(0, 0) == rgb{1, 1, 1});
+}
+
+TEST_CASE("script screen drawing: rectangles and images are clipped to the image") {
+	canvas board{3, 2, rgb{0, 0, 0}};
+	board.fill_rect(-5, 1, 100, 100, rgb{1, 2, 3});
+	CHECK(board.get(0, 0) == rgb{0, 0, 0});
+	CHECK(board.get(0, 1) == rgb{1, 2, 3});
+	CHECK(board.get(2, 1) == rgb{1, 2, 3});
+	CHECK(board.get(5, 5) == rgb{0, 0, 0});
+
+	canvas const stamp{2, 2, rgb{7, 7, 7}};
+	board.draw_image(stamp, 2, -1);
+	CHECK(board.get(2, 0) == rgb{7, 7, 7});
+	CHECK(board.get(1, 0) == rgb{0, 0, 0});
+	// every pixel opaque
+	CHECK(board.pixels()[3] == 255);
+}
diff --git a/tests/unit/test_script_screen_host.cpp b/tests/unit/test_script_screen_host.cpp
new file mode 100644
index 00000000..63ffea5d
--- /dev/null
+++ b/tests/unit/test_script_screen_host.cpp
@@ -0,0 +1,596 @@
+#include "stdafx.h"
+#include "doctest.h"
+
+// the script screen host (scripting/scriptscreens.cpp) with the real runtimes: a script reads its input, draws an
+// image that goes to the screen's texture, bottom row first, and sends a command; a script stuck in a loop is stopped;
+// a Lua script can't reach files, the system or precompiled code. the Lua cases need WITH_LUA, the WebAssembly ones
+// WITH_WASM
+
+#include "scripting/scriptscreens.h"
+#include "input/command.h"
+#include "interfaces/ITexture.h"
+#include "utilities/Globals.h"
+#include "utilities/dictionary.h"
+
+#include <array>
+#include <chrono>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <functional>
+#include <span>
+#include <string_view>
+#include <thread>
+#include <vector>
+
+// the engine's command queue and command names, which the test build doesn't link: the commands the screens send
+// are kept here instead
+
+namespace {
+
+std::vector<std::pair<command_data, std::uint32_t>> &sent_commands() {
+	static std::vector<std::pair<command_data, std::uint32_t>> commands;
+	return commands;
+}
+
+} // namespace
+
+namespace simulation {
+command_queue Commands; // NOSONAR the engine's extern global, input/command.h
+std::unordered_map<std::string, user_command> const commandMap{{"cmdtest", user_command::aidriverenable}}; // NOSONAR the engine's extern global, input/command.h
+} // namespace simulation
+
+void command_queue::push(command_data const &Command, uint32_t const Recipient) { // NOSONAR signature from input/command.h
+	sent_commands().emplace_back(Command, Recipient);
+}
+
+namespace {
+
+// a texture that keeps what was uploaded to it
+struct recording_texture : ITexture {
+	bool create(bool) override { return true; }
+	int get_width() const override { return width; }
+	int get_height() const override { return height; }
+	size_t get_id() const override { return id; }
+	void release() override { /* nothing held */ }
+	void make_stub() override { /* nothing held */ }
+	std::string_view get_traits() const override { return ""; }
+	std::string_view get_name() const override { return "recording"; }
+	std::string_view get_type() const override { return "make:"; }
+	bool is_stub() const override { return false; }
+	bool get_has_alpha() const override { return true; }
+	bool get_is_ready() const override { return ready; }
+	void set_components_hint(int) override { /* not used */ }
+	void make_from_memory(size_t const Width, size_t const Height, const uint8_t *Data) override { update_from_memory(Width, Height, Data); }
+	void update_from_memory(size_t const Width, size_t const Height, const uint8_t *Data) override {
+		width = static_cast<int>(Width);
+		height = static_cast<int>(Height);
+		pixels.assign(Data, Data + Width * Height * 4);
+		++uploads;
+	}
+
+	bool ready{true};
+	size_t id{1};
+	int width{0};
+	int height{0};
+	int uploads{0};
+	std::vector<std::uint8_t> pixels;
+};
+
+// a folder of its own for the scripts of a test, removed with the object
+class script_folder {
+  public:
+	explicit script_folder(std::string const &Name)
+	    : m_folder{std::filesystem::temp_directory_path() / std::format("eu07_script_screen_test_{}", Name)} {
+		std::filesystem::remove_all(m_folder);
+		std::filesystem::create_directories(m_folder);
+	}
+	~script_folder() {
+		std::error_code error;
+		std::filesystem::remove_all(m_folder, error);
+	}
+	script_folder(script_folder const &) = delete;
+	script_folder &operator=(script_folder const &) = delete;
+
+	// writes the file, returns its path as the game names scripts
+	std::string write(std::string const &Name, std::span<std::uint8_t const> const Bytes) const {
+		auto const path{m_folder / Name};
+		std::filesystem::create_directories(path.parent_path());
+		std::ofstream file{path, std::ios::binary};
+		file.write(reinterpret_cast<char const *>(Bytes.data()), static_cast<std::streamsize>(Bytes.size()));
+		return path.generic_string();
+	}
+	std::string write(std::string const &Name, std::string_view const Text) const {
+		return write(Name, std::span{reinterpret_cast<std::uint8_t const *>(Text.data()), Text.size()});
+	}
+
+  private:
+	std::filesystem::path m_folder;
+};
+
+// runs frames until the condition holds, or gives up after a few seconds
+bool run_until(script_screen_queue &Queue, std::function<bool()> const &Condition) {
+	auto const deadline{std::chrono::steady_clock::now() + std::chrono::seconds(20)};
+	while (std::chrono::steady_clock::now() < deadline) {
+		Queue.update();
+		if (Condition()) {
+			return true;
+		}
+		std::this_thread::sleep_for(std::chrono::milliseconds(5));
+	}
+	return false;
+}
+
+std::shared_ptr<dictionary_source> speed(double const Value) {
+	auto input{std::make_shared<dictionary_source>()};
+	input->insert("speed", Value);
+	return input;
+}
+
+script_screen_queue::screen_request request(script_language const Language, std::string const &Script, std::string const &Key, ITexture *Texture,
+                                            script_screen_kind const Kind = script_screen_kind::cab) {
+	return {.kind = Kind, .language = Language, .script = Script, .key = Key, .texture = Texture, .frames = 0};
+}
+
+// submits a refresh as soon as the screen is due
+void refresh(script_screen_queue &Queue, std::shared_ptr<script_screen> const &Screen, std::shared_ptr<dictionary_source> Input, std::uint32_t const Vehicle) {
+	REQUIRE(run_until(Queue, [&Queue, &Screen] { return Queue.due(*Screen); }));
+	Queue.submit(Screen, std::move(Input), Vehicle);
+}
+
+} // namespace
+
+TEST_CASE("script screens: a language that doesn't run gets no screens") {
+	script_screen_queue queue;
+	// not started
+	CHECK_FALSE(queue.runs(script_language::lua));
+	CHECK(queue.acquire(request(script_language::lua, "x.lua", "x", nullptr)) == nullptr);
+}
+
+TEST_CASE("script screens: the language of a script is told by its extension") {
+	CHECK(script_language_of("scripts/led_111a20.lua") == script_language::lua);
+	CHECK(script_language_of("dynamic/pkp/x/ekran.wasm") == script_language::wasm);
+	CHECK_FALSE(script_language_of("scripts/led_111a20").has_value());
+}
+
+#ifdef WITH_WASM
+
+namespace {
+
+// the modules, encoded by hand. "paint": a 2x2 screen in the colour 0xFF0000vv, vv being the input value
+// "speed", which sends the command "cmdtest" with the parameters (vv, 7):
+//   (import "eu07" "get_float" (func $get_float (param i32 i32) (result f64)))
+//   (import "eu07" "command" (func $command (param i32 i32 i32 i32)))
+//   (memory (export "memory") 1)
+//   (data (i32.const 0) "speed") (data (i32.const 16) "cmdtest")
+//   (func (export "screen_width") (result i32) i32.const 2)
+//   (func (export "screen_height") (result i32) i32.const 2)
+//   (func (export "screen_render") (result i32) (local $v i32)
+//     (local.set $v (i32.trunc_f64_s (call $get_float (i32.const 0) (i32.const 5))))
+//     (i32.store (i32.const 1024) (i32.or (local.get $v) (i32.const 0xFF000000))) ... the same at 1028, 1032, 1036
+//     (call $command (i32.const 16) (i32.const 7) (local.get $v) (i32.const 7))
+//     (i32.const 1024))
+constexpr std::array<std::uint8_t, 254> paint_module{
+	0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x12, 0x03, 0x60, 0x02, 0x7f, 0x7f, 0x01,
+	0x7c, 0x60, 0x04, 0x7f, 0x7f, 0x7f, 0x7f, 0x00, 0x60, 0x00, 0x01, 0x7f, 0x02, 0x21, 0x02, 0x04,
+	0x65, 0x75, 0x30, 0x37, 0x09, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x00, 0x00,
+	0x04, 0x65, 0x75, 0x30, 0x37, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x00, 0x01, 0x03,
+	0x04, 0x03, 0x02, 0x02, 0x02, 0x05, 0x03, 0x01, 0x00, 0x01, 0x07, 0x39, 0x04, 0x06, 0x6d, 0x65,
+	0x6d, 0x6f, 0x72, 0x79, 0x02, 0x00, 0x0c, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x77, 0x69,
+	0x64, 0x74, 0x68, 0x00, 0x02, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x68, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x00, 0x03, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x72, 0x65, 0x6e,
+	0x64, 0x65, 0x72, 0x00, 0x04, 0x0a, 0x5e, 0x03, 0x04, 0x00, 0x41, 0x02, 0x0b, 0x04, 0x00, 0x41,
+	0x02, 0x0b, 0x52, 0x01, 0x01, 0x7f, 0x41, 0x00, 0x41, 0x05, 0x10, 0x00, 0xaa, 0x21, 0x00, 0x41,
+	0x80, 0x08, 0x20, 0x00, 0x41, 0x80, 0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x84, 0x08,
+	0x20, 0x00, 0x41, 0x80, 0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x88, 0x08, 0x20, 0x00,
+	0x41, 0x80, 0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x8c, 0x08, 0x20, 0x00, 0x41, 0x80,
+	0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x10, 0x41, 0x07, 0x20, 0x00, 0x41, 0x07, 0x10,
+	0x01, 0x41, 0x80, 0x08, 0x0b, 0x0b, 0x17, 0x02, 0x00, 0x41, 0x00, 0x0b, 0x05, 0x73, 0x70, 0x65,
+	0x65, 0x64, 0x00, 0x41, 0x10, 0x0b, 0x07, 0x63, 0x6d, 0x64, 0x74, 0x65, 0x73, 0x74};
+
+// "spin": exports the same functions as "paint", but screen_render never returns: (loop $l (br $l))
+constexpr std::array<std::uint8_t, 108> spin_module{
+	0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x05, 0x01, 0x60, 0x00, 0x01, 0x7f, 0x03,
+	0x04, 0x03, 0x00, 0x00, 0x00, 0x05, 0x03, 0x01, 0x00, 0x01, 0x07, 0x39, 0x04, 0x06, 0x6d, 0x65,
+	0x6d, 0x6f, 0x72, 0x79, 0x02, 0x00, 0x0c, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x77, 0x69,
+	0x64, 0x74, 0x68, 0x00, 0x00, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x68, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x00, 0x01, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x72, 0x65, 0x6e,
+	0x64, 0x65, 0x72, 0x00, 0x02, 0x0a, 0x15, 0x03, 0x04, 0x00, 0x41, 0x02, 0x0b, 0x04, 0x00, 0x41,
+	0x02, 0x0b, 0x09, 0x00, 0x03, 0x40, 0x0c, 0x00, 0x0b, 0x41, 0x00, 0x0b};
+
+} // namespace
+
+TEST_CASE("wasm screens: a cab screen draws from its input and sends commands to its vehicle") {
+	sent_commands().clear();
+	script_folder const folder{"wasm_paint"};
+	auto const module{folder.write("paint.wasm", paint_module)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+	REQUIRE(queue.runs(script_language::wasm));
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::wasm, module, "cab", &texture))};
+	REQUIRE(screen != nullptr);
+	// the same key, the same screen
+	CHECK(queue.acquire(request(script_language::wasm, module, "cab", &texture)) == screen);
+
+	refresh(queue, screen, speed(5.0), 42);
+	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0 && false == sent_commands().empty(); }));
+
+	CHECK(texture.width == 2);
+	CHECK(texture.height == 2);
+	REQUIRE(texture.pixels.size() == 16);
+	std::array<std::uint8_t, 4> const expected{0x05, 0x00, 0x00, 0xFF};
+	for (std::size_t pixel = 0; pixel < 4; ++pixel) {
+		CAPTURE(pixel);
+		CHECK(std::equal(expected.begin(), expected.end(), texture.pixels.begin() + static_cast<std::ptrdiff_t>(pixel * 4)));
+	}
+
+	REQUIRE(sent_commands().size() == 1);
+	auto const &[command, recipient]{sent_commands().front()};
+	CHECK(command.command == user_command::aidriverenable);
+	CHECK(command.param1 == 5.0);
+	CHECK(command.param2 == 7.0);
+	CHECK(recipient == (static_cast<std::uint32_t>(command_target::vehicle) | 42u));
+
+	queue.exit();
+}
+
+TEST_CASE("wasm screens: the image goes up again when the texture is made anew, and waits while it isn't there") {
+	sent_commands().clear();
+	script_folder const folder{"wasm_reupload"};
+	auto const module{folder.write("paint.wasm", paint_module)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture texture;
+	texture.ready = false;
+	auto const screen{queue.acquire(request(script_language::wasm, module, "cab", &texture))};
+	refresh(queue, screen, speed(9.0), 1);
+	REQUIRE(run_until(queue, [] { return false == sent_commands().empty(); }));
+	queue.update();
+	CHECK(texture.uploads == 0);
+
+	texture.ready = true;
+	queue.update();
+	CHECK(texture.uploads == 1);
+	queue.update();
+	CHECK(texture.uploads == 1);
+
+	// released and made again: a new gl texture
+	texture.id = 2;
+	queue.update();
+	CHECK(texture.uploads == 2);
+
+	queue.exit();
+}
+
+TEST_CASE("wasm screens: a screen outside the cab draws, but its commands are dropped") {
+	sent_commands().clear();
+	script_folder const folder{"wasm_sign"};
+	auto const module{folder.write("paint.wasm", paint_module)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::wasm, module, "sign", &texture, script_screen_kind::external))};
+	refresh(queue, screen, speed(3.0), 0);
+	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
+	queue.update();
+	CHECK(sent_commands().empty());
+
+	queue.exit();
+}
+
+TEST_CASE("wasm screens: a screen stuck in a loop is stopped, and the others keep working") {
+	script_folder const folder{"wasm_spin"};
+	auto const spinning{folder.write("spin.wasm", spin_module)};
+	auto const painting{folder.write("paint.wasm", paint_module)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture stuck;
+	recording_texture working;
+	auto const first{queue.acquire(request(script_language::wasm, spinning, "spin", &stuck))};
+	auto const second{queue.acquire(request(script_language::wasm, painting, "paint", &working))};
+	refresh(queue, first, speed(1.0), 1);
+	refresh(queue, second, speed(2.0), 1);
+
+	REQUIRE(run_until(queue, [&working] { return working.uploads > 0; }));
+	CHECK(stuck.uploads == 0);
+	// the stuck screen ran first, into the instruction limit, and isn't due any more
+	CHECK_FALSE(queue.due(*first));
+
+	queue.exit();
+}
+
+TEST_CASE("wasm screens: the screens outlive the queue without harm") {
+	script_folder const folder{"wasm_outlive"};
+	auto const module{folder.write("paint.wasm", paint_module)};
+	std::shared_ptr<script_screen> screen;
+	recording_texture texture;
+	{
+		script_screen_queue queue;
+		REQUIRE(queue.init());
+		screen = queue.acquire(request(script_language::wasm, module, "cab", &texture));
+		refresh(queue, screen, speed(4.0), 1);
+		REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
+	}
+	// the queue and the runtime are gone, the vehicle still holds its screen
+	CHECK(screen != nullptr);
+	screen.reset();
+}
+
+#endif
+
+#ifdef WITH_LUA
+
+#include "stb/stb_image.h"
+#include "stb/stb_image_write.h"
+
+namespace {
+
+// the game's texture loader turns every image stb_image reads bottom row first (model/Texture.cpp); for the length of
+// a test, the same here
+class images_flipped_as_in_the_game {
+  public:
+	images_flipped_as_in_the_game() { stbi_set_flip_vertically_on_load(1); }
+	~images_flipped_as_in_the_game() { stbi_set_flip_vertically_on_load(0); }
+	images_flipped_as_in_the_game(images_flipped_as_in_the_game const &) = delete;
+	images_flipped_as_in_the_game &operator=(images_flipped_as_in_the_game const &) = delete;
+};
+
+// a 2x2 screen in the colour (speed, 0, 0), sending the command "cmdtest" with (speed, 7)
+constexpr std::string_view paint_script{R"(
+local screen = {}
+function screen.render(state)
+	eu07.command("cmdtest", state.speed, 7)
+	return eu07.image(2, 2, { state.speed, 0, 0 })
+end
+return screen
+)"};
+
+// 1x2: a red row above a green one
+constexpr std::string_view rows_script{R"(
+return {
+	render = function(state)
+		local image = eu07.image(1, 2, { 0, 0, 0 })
+		image:set(0, 0, { 255, 0, 0 })
+		image:set(0, 1, { 0, 255, 0 })
+		return image
+	end
+}
+)"};
+
+// 1x1, white when nothing of the world outside the sandbox is reachable, black otherwise
+constexpr std::string_view sandbox_script{R"(
+local reachable = io or os or ffi or debug or package or require or load or loadstring or dofile or loadfile or string.dump or jit
+local escapes = eu07.read_file("../outside.txt") or eu07.read_file("/etc/hosts") or eu07.read_file("c:/windows/win.ini")
+local inside = eu07.read_file("data/inside.txt")
+local ok = not reachable and not escapes and inside == "inside"
+return {
+	render = function(state)
+		return eu07.image(1, 1, ok and { 255, 255, 255 } or { 0, 0, 0 })
+	end
+}
+)"};
+
+// never returns from render
+constexpr std::string_view spin_script{R"(
+return { render = function(state) while true do end end }
+)"};
+
+// draws once, then reports nothing new
+constexpr std::string_view once_script{R"(
+local drawn = false
+return {
+	render = function(state)
+		if drawn then return nil end
+		drawn = true
+		return eu07.image(1, 1, { 1, 2, 3 })
+	end
+}
+)"};
+
+// uses a helper script and a font next to it
+constexpr std::string_view include_script{R"(
+local helper = eu07.include("helper.lua")
+local font = eu07.font("font/test")
+return {
+	render = function(state)
+		local image = eu07.image(8, 2, { 0, 0, 0 })
+		local x = image:draw_text(font, 0, 0, helper.text, { 255, 0, 0 })
+		image:set(7, 1, { x, font:text_width("ab"), font:height() })
+		return image
+	end
+}
+)"};
+
+constexpr std::string_view helper_script{R"(
+return { text = "ab" }
+)"};
+
+// a font of two glyphs a column apart: "a" two columns wide, lit in its top row, "b" one column, lit in both rows.
+// written as a .png by stb_image_write, the way the game's fonts are
+std::vector<std::uint8_t> test_font_png() {
+	constexpr int width{4};
+	constexpr int height{2};
+	std::array<std::uint8_t, width * height * 4> pixels{};
+	pixels.fill(255);
+	auto const lit{[&pixels](int const X, int const Y) { pixels[(Y * width + X) * 4] = 0; }};
+	lit(0, 0);
+	lit(1, 0);
+	lit(3, 0);
+	lit(3, 1);
+	std::vector<std::uint8_t> result;
+	auto const append{[](void *Target, void *Data, int const Size) {
+		auto *bytes{static_cast<std::uint8_t const *>(Data)};
+		static_cast<std::vector<std::uint8_t> *>(Target)->insert(static_cast<std::vector<std::uint8_t> *>(Target)->end(), bytes, bytes + Size);
+	}};
+	stbi_write_png_to_func(append, &result, width, height, 4, pixels.data(), width * 4);
+	return result;
+}
+
+} // namespace
+
+TEST_CASE("lua screens: a cab screen draws from its input and sends commands to its vehicle") {
+	sent_commands().clear();
+	script_folder const folder{"lua_paint"};
+	auto const script{folder.write("paint.lua", paint_script)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+	REQUIRE(queue.runs(script_language::lua));
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::lua, script, "cab", &texture))};
+	REQUIRE(screen != nullptr);
+	refresh(queue, screen, speed(5.0), 42);
+	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0 && false == sent_commands().empty(); }));
+
+	CHECK(texture.width == 2);
+	CHECK(texture.height == 2);
+	REQUIRE(texture.pixels.size() == 16);
+	CHECK(texture.pixels[0] == 5);
+	CHECK(texture.pixels[1] == 0);
+	CHECK(texture.pixels[3] == 255);
+
+	REQUIRE(sent_commands().size() == 1);
+	auto const &[command, recipient]{sent_commands().front()};
+	CHECK(command.command == user_command::aidriverenable);
+	CHECK(command.param1 == 5.0);
+	CHECK(command.param2 == 7.0);
+	CHECK(recipient == (static_cast<std::uint32_t>(command_target::vehicle) | 42u));
+	queue.exit();
+}
+
+TEST_CASE("lua screens: the texture gets the bottom row first, as from the python screens") {
+	script_folder const folder{"lua_rows"};
+	auto const script{folder.write("rows.lua", rows_script)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::lua, script, "rows", &texture))};
+	refresh(queue, screen, speed(0.0), 1);
+	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
+	REQUIRE(texture.pixels.size() == 8);
+	// green, the bottom row, first
+	CHECK(texture.pixels[0] == 0);
+	CHECK(texture.pixels[1] == 255);
+	CHECK(texture.pixels[4] == 255);
+	CHECK(texture.pixels[5] == 0);
+	queue.exit();
+}
+
+TEST_CASE("lua screens: a script reaches no files outside its folder, nor the system, nor ffi") {
+	script_folder const folder{"lua_sandbox"};
+	folder.write("../outside.txt", std::string_view{"outside"});
+	folder.write("data/inside.txt", std::string_view{"inside"});
+	auto const script{folder.write("sandbox.lua", sandbox_script)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::lua, script, "sandbox", &texture))};
+	refresh(queue, screen, speed(0.0), 1);
+	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
+	REQUIRE(texture.pixels.size() == 4);
+	CHECK(texture.pixels[0] == 255);
+	queue.exit();
+	std::filesystem::remove(std::filesystem::temp_directory_path() / "outside.txt");
+}
+
+TEST_CASE("lua screens: precompiled code isn't loaded") {
+	script_folder const folder{"lua_bytecode"};
+	// LuaJIT bytecode starts with ESC "LJ"
+	auto const script{folder.write("compiled.lua", std::string_view{"\x1bLJ\x02\x00 not a script"})};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::lua, script, "compiled", &texture))};
+	refresh(queue, screen, speed(0.0), 1);
+	// it fails to load, and isn't refreshed again: a screen that runs would be due again within a few frames
+	for (int frame = 0; frame < 40; ++frame) {
+		queue.update();
+		std::this_thread::sleep_for(std::chrono::milliseconds(5));
+	}
+	CHECK_FALSE(queue.due(*screen));
+	CHECK(texture.uploads == 0);
+	queue.exit();
+}
+
+TEST_CASE("lua screens: a script stuck in a loop is stopped, and the others keep working") {
+	script_folder const folder{"lua_spin"};
+	auto const spinning{folder.write("spin.lua", spin_script)};
+	auto const painting{folder.write("paint.lua", paint_script)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture stuck;
+	recording_texture working;
+	auto const first{queue.acquire(request(script_language::lua, spinning, "spin", &stuck))};
+	auto const second{queue.acquire(request(script_language::lua, painting, "paint", &working))};
+	refresh(queue, first, speed(1.0), 1);
+	refresh(queue, second, speed(2.0), 1);
+
+	REQUIRE(run_until(queue, [&working] { return working.uploads > 0; }));
+	CHECK(stuck.uploads == 0);
+	CHECK_FALSE(queue.due(*first));
+	queue.exit();
+}
+
+TEST_CASE("lua screens: nil from render keeps the image there is") {
+	script_folder const folder{"lua_once"};
+	auto const script{folder.write("once.lua", once_script)};
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::lua, script, "once", &texture))};
+	refresh(queue, screen, speed(0.0), 1);
+	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
+	refresh(queue, screen, speed(0.0), 1);
+	refresh(queue, screen, speed(0.0), 1);
+	for (int frame = 0; frame < 20; ++frame) {
+		queue.update();
+		std::this_thread::sleep_for(std::chrono::milliseconds(5));
+	}
+	CHECK(texture.uploads == 1);
+	CHECK(texture.pixels[2] == 3);
+	queue.exit();
+}
+
+TEST_CASE("lua screens: a script includes another and reads a font of the python screens' format") {
+	script_folder const folder{"lua_include"};
+	auto const script{folder.write("include.lua", include_script)};
+	folder.write("helper.lua", helper_script);
+	folder.write("font/test.png", test_font_png());
+	folder.write("font/test.txt", std::string_view{"// a comment line\r\na2\r\nb1\r\n"});
+	// the fonts are read top row first all the same
+	images_flipped_as_in_the_game const flipped;
+	script_screen_queue queue;
+	REQUIRE(queue.init());
+
+	recording_texture texture;
+	auto const screen{queue.acquire(request(script_language::lua, script, "include", &texture))};
+	refresh(queue, screen, speed(0.0), 1);
+	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
+	REQUIRE(texture.pixels.size() == 8 * 2 * 4);
+	// bottom row first: the top row of the image is the second row of the texture
+	auto const top{[&texture](int const X) { return texture.pixels[(8 + X) * 4]; }};
+	auto const bottom{[&texture](int const X) { return texture.pixels[X * 4]; }};
+	CHECK(top(0) == 255);
+	CHECK(top(1) == 255);
+	CHECK(top(2) == 0); // the spacing column
+	CHECK(top(3) == 255);
+	CHECK(bottom(0) == 0);
+	CHECK(bottom(3) == 255);
+	// the x after the text (2 + 1 + 1 + 1), its width and the font's height
+	CHECK(texture.pixels[7 * 4] == 5);
+	CHECK(texture.pixels[7 * 4 + 1] == 5);
+	CHECK(texture.pixels[7 * 4 + 2] == 2);
+	queue.exit();
+}
+
+#endif
diff --git a/tests/unit/test_wasm_kernels.cpp b/tests/unit/test_script_screen_kernels.cpp
similarity index 82%
rename from tests/unit/test_wasm_kernels.cpp
rename to tests/unit/test_script_screen_kernels.cpp
index 618524c7..445cc8a7 100644
--- a/tests/unit/test_wasm_kernels.cpp
+++ b/tests/unit/test_script_screen_kernels.cpp
@@ -1,13 +1,13 @@
 #include "stdafx.h"
 #include "doctest.h"
 
-#include "scripting/wasmscreenkernels.h"
+#include "scripting/scriptscreenkernels.h"
 
 #include <array>
 #include <span>
 #include <vector>
 
-// the image filters the wasm screens call through the host give the pixels of the Python screens: led_util's
+// the image filters the script screens call through the host give the pixels of the Python screens: led_util's
 // render_post() and Pillow's resize(..., Image.LANCZOS). the expected images were made by them (Pillow 12.2) from a
 // 5x3 image of (x*53 + y*97, x*31 + y*17 + 100, x*7 + y*151 + 40) mod 256
 
@@ -90,32 +90,32 @@ std::vector<std::uint8_t> rgba(std::span<std::uint8_t const> const Rgb) {
 
 } // namespace
 
-TEST_CASE("wasm kernels: led_post gives the pixels of led_util.render_post") {
+TEST_CASE("script screen kernels: led_post gives the pixels of led_util.render_post") {
 	auto const input{rgba(source)};
-	std::vector<std::uint8_t> output(wasm_screens::image_size(12, 8), 7);
-	REQUIRE(wasm_screens::led_post(input, 5, 3, output, true));
+	std::vector<std::uint8_t> output(script_screens::image_size(12, 8), 7);
+	REQUIRE(script_screens::led_post(input, 5, 3, output, true));
 	CHECK(output == rgba(posted));
 
-	REQUIRE(wasm_screens::led_post(input, 5, 3, output, false));
+	REQUIRE(script_screens::led_post(input, 5, 3, output, false));
 	CHECK(output == rgba(plain));
 }
 
-TEST_CASE("wasm kernels: resize_lanczos gives the pixels of Pillow's resize with LANCZOS") {
+TEST_CASE("script screen kernels: resize_lanczos gives the pixels of Pillow's resize with LANCZOS") {
 	auto const input{rgba(posted)};
-	std::vector<std::uint8_t> larger(wasm_screens::image_size(17, 11));
-	REQUIRE(wasm_screens::resize_lanczos(input, 12, 8, larger, 17, 11));
+	std::vector<std::uint8_t> larger(script_screens::image_size(17, 11));
+	REQUIRE(script_screens::resize_lanczos(input, 12, 8, larger, 17, 11));
 	CHECK(larger == rgba(enlarged));
 
-	std::vector<std::uint8_t> smaller(wasm_screens::image_size(7, 5));
-	REQUIRE(wasm_screens::resize_lanczos(input, 12, 8, smaller, 7, 5));
+	std::vector<std::uint8_t> smaller(script_screens::image_size(7, 5));
+	REQUIRE(script_screens::resize_lanczos(input, 12, 8, smaller, 7, 5));
 	CHECK(smaller == rgba(reduced));
 }
 
-TEST_CASE("wasm kernels: images that don't fit their buffers are refused") {
-	std::vector<std::uint8_t> const input(wasm_screens::image_size(5, 3));
-	std::vector<std::uint8_t> output(wasm_screens::image_size(12, 8) - 1);
-	CHECK_FALSE(wasm_screens::led_post(input, 5, 3, output, true));
-	CHECK_FALSE(wasm_screens::led_post(input, 0, 3, output, true));
-	CHECK_FALSE(wasm_screens::resize_lanczos(input, 5, 3, output, 12, 8));
-	CHECK_FALSE(wasm_screens::resize_lanczos(input, 6, 3, output, 2, 2));
+TEST_CASE("script screen kernels: images that don't fit their buffers are refused") {
+	std::vector<std::uint8_t> const input(script_screens::image_size(5, 3));
+	std::vector<std::uint8_t> output(script_screens::image_size(12, 8) - 1);
+	CHECK_FALSE(script_screens::led_post(input, 5, 3, output, true));
+	CHECK_FALSE(script_screens::led_post(input, 0, 3, output, true));
+	CHECK_FALSE(script_screens::resize_lanczos(input, 5, 3, output, 12, 8));
+	CHECK_FALSE(script_screens::resize_lanczos(input, 6, 3, output, 2, 2));
 }
diff --git a/tests/unit/test_wasm_screens.cpp b/tests/unit/test_script_screens.cpp
similarity index 59%
rename from tests/unit/test_wasm_screens.cpp
rename to tests/unit/test_script_screens.cpp
index 5224f4b9..9e0bb7a9 100644
--- a/tests/unit/test_wasm_screens.cpp
+++ b/tests/unit/test_script_screens.cpp
@@ -1,16 +1,16 @@
 #include "stdafx.h"
 #include "doctest.h"
 
-#include "scripting/wasmscreenrules.h"
+#include "scripting/scriptscreenrules.h"
 #include "utilities/parser.h"
 
-// the parts of the wasm screens that don't need the runtime: the .mmd entries, the refresh schedule counted in
+// the parts of the script screens that don't need the runtime: the .mmd entries, the refresh schedule counted in
 // frames and the files a screen may read
 
-using wasm_screens::frame_schedule;
-using wasm_screens::screen_config;
+using script_screens::frame_schedule;
+using script_screens::screen_config;
 
-TEST_CASE("wasm screens: a cab screen entry with every key") {
+TEST_CASE("script screens: a cab screen entry with every key") {
 	cParser parser("{ ekran.wasm target: screen01 frames: 6 parameters: id=1&mode=full } next:", cParser::buffer_TEXT);
 	screen_config config;
 	config.deserialize(parser);
@@ -23,7 +23,7 @@ TEST_CASE("wasm screens: a cab screen entry with every key") {
 	CHECK(parser.getToken<std::string>() == "next:");
 }
 
-TEST_CASE("wasm screens: the optional keys keep their defaults, an unknown key is skipped with its value") {
+TEST_CASE("script screens: the optional keys keep their defaults, an unknown key is skipped with its value") {
 	cParser parser("{ tablica.wasm later: 12 instance: name background: tablica_off }", cParser::buffer_TEXT);
 	screen_config config;
 	config.deserialize(parser);
@@ -36,7 +36,7 @@ TEST_CASE("wasm screens: the optional keys keep their defaults, an unknown key i
 	CHECK(config.background == "tablica_off");
 }
 
-TEST_CASE("wasm screens: the interval set in eu07.ini, or the screen's own when it is longer") {
+TEST_CASE("script screens: the interval set in eu07.ini, or the screen's own when it is longer") {
 	CHECK(frame_schedule::effective_interval(4, 0) == 4);
 	CHECK(frame_schedule::effective_interval(4, 10) == 10);
 	CHECK(frame_schedule::effective_interval(4, 2) == 4);
@@ -45,7 +45,7 @@ TEST_CASE("wasm screens: the interval set in eu07.ini, or the screen's own when
 	CHECK(frame_schedule::effective_interval(-3, -1) == 1);
 }
 
-TEST_CASE("wasm screens: a screen is due once per interval") {
+TEST_CASE("script screens: a screen is due once per interval") {
 	frame_schedule schedule{100, 3, 0};
 	CHECK(schedule.poll(100));
 	// asked again in the same frame (the vehicle drawn in more than one pass)
@@ -57,7 +57,7 @@ TEST_CASE("wasm screens: a screen is due once per interval") {
 	CHECK(schedule.poll(106));
 }
 
-TEST_CASE("wasm screens: a screen out of sight for a while is due on the first frame it is asked again") {
+TEST_CASE("script screens: a screen out of sight for a while is due on the first frame it is asked again") {
 	frame_schedule schedule{0, 5, 0};
 	CHECK(schedule.poll(0));
 	CHECK(schedule.poll(42));
@@ -65,7 +65,7 @@ TEST_CASE("wasm screens: a screen out of sight for a while is due on the first f
 	CHECK(schedule.poll(47));
 }
 
-TEST_CASE("wasm screens: the phase spreads the screens over the frames of an interval") {
+TEST_CASE("script screens: the phase spreads the screens over the frames of an interval") {
 	auto const interval{30};
 	auto const phase{frame_schedule::phase("make:dynamic/pkp/ed72/tablica.wasm?$timetable=ed72-001", interval)};
 	CHECK(phase >= 0);
@@ -86,18 +86,18 @@ TEST_CASE("wasm screens: the phase spreads the screens over the frames of an int
 	CHECK(first == 1000 + static_cast<std::uint64_t>(phase));
 }
 
-TEST_CASE("wasm screens: a screen reads files only below its own folder") {
-	CHECK(wasm_screens::is_safe_relative_path("font.png"));
-	CHECK(wasm_screens::is_safe_relative_path("data/font.png"));
-	CHECK(wasm_screens::is_safe_relative_path("data\\font.png"));
-	CHECK(wasm_screens::is_safe_relative_path("data/..font.png"));
+TEST_CASE("script screens: a screen reads files only below its own folder") {
+	CHECK(script_screens::is_safe_relative_path("font.png"));
+	CHECK(script_screens::is_safe_relative_path("data/font.png"));
+	CHECK(script_screens::is_safe_relative_path("data\\font.png"));
+	CHECK(script_screens::is_safe_relative_path("data/..font.png"));
 
-	CHECK_FALSE(wasm_screens::is_safe_relative_path(""));
-	CHECK_FALSE(wasm_screens::is_safe_relative_path("../eu07.ini"));
-	CHECK_FALSE(wasm_screens::is_safe_relative_path("data/../../eu07.ini"));
-	CHECK_FALSE(wasm_screens::is_safe_relative_path("data\\..\\x"));
-	CHECK_FALSE(wasm_screens::is_safe_relative_path(".."));
-	CHECK_FALSE(wasm_screens::is_safe_relative_path("/etc/passwd"));
-	CHECK_FALSE(wasm_screens::is_safe_relative_path("\\windows"));
-	CHECK_FALSE(wasm_screens::is_safe_relative_path("c:/windows/win.ini"));
+	CHECK_FALSE(script_screens::is_safe_relative_path(""));
+	CHECK_FALSE(script_screens::is_safe_relative_path("../eu07.ini"));
+	CHECK_FALSE(script_screens::is_safe_relative_path("data/../../eu07.ini"));
+	CHECK_FALSE(script_screens::is_safe_relative_path("data\\..\\x"));
+	CHECK_FALSE(script_screens::is_safe_relative_path(".."));
+	CHECK_FALSE(script_screens::is_safe_relative_path("/etc/passwd"));
+	CHECK_FALSE(script_screens::is_safe_relative_path("\\windows"));
+	CHECK_FALSE(script_screens::is_safe_relative_path("c:/windows/win.ini"));
 }
diff --git a/tests/unit/test_wasm_host.cpp b/tests/unit/test_wasm_host.cpp
deleted file mode 100644
index d96ee716..00000000
--- a/tests/unit/test_wasm_host.cpp
+++ /dev/null
@@ -1,288 +0,0 @@
-#include "stdafx.h"
-#include "doctest.h"
-
-// the wasm screen host (scripting/wasmscreens.cpp) with the real runtime: a module reads its input, draws an
-// image that goes to the screen's texture and sends a command; a module stuck in a loop is stopped. built with
-// WITH_WASM only
-
-#ifdef WITH_WASM
-
-#include "scripting/wasmscreens.h"
-#include "input/command.h"
-#include "interfaces/ITexture.h"
-#include "utilities/Globals.h"
-#include "utilities/dictionary.h"
-
-#include <array>
-#include <chrono>
-#include <filesystem>
-#include <format>
-#include <fstream>
-#include <functional>
-#include <thread>
-#include <vector>
-
-// the engine's command queue and command names, which the test build doesn't link: the commands the screens send
-// are kept here instead
-
-namespace {
-
-std::vector<std::pair<command_data, std::uint32_t>> &sent_commands() {
-	static std::vector<std::pair<command_data, std::uint32_t>> commands;
-	return commands;
-}
-
-} // namespace
-
-namespace simulation {
-command_queue Commands; // NOSONAR the engine's extern global, input/command.h
-std::unordered_map<std::string, user_command> const commandMap{{"cmdtest", user_command::aidriverenable}}; // NOSONAR the engine's extern global, input/command.h
-} // namespace simulation
-
-void command_queue::push(command_data const &Command, uint32_t const Recipient) { // NOSONAR signature from input/command.h
-	sent_commands().emplace_back(Command, Recipient);
-}
-
-namespace {
-
-// the modules, encoded by hand. "paint": a 2x2 screen in the colour 0xFF0000vv, vv being the input value
-// "speed", which sends the command "cmdtest" with the parameters (vv, 7):
-//   (import "eu07" "get_float" (func $get_float (param i32 i32) (result f64)))
-//   (import "eu07" "command" (func $command (param i32 i32 i32 i32)))
-//   (memory (export "memory") 1)
-//   (data (i32.const 0) "speed") (data (i32.const 16) "cmdtest")
-//   (func (export "screen_width") (result i32) i32.const 2)
-//   (func (export "screen_height") (result i32) i32.const 2)
-//   (func (export "screen_render") (result i32) (local $v i32)
-//     (local.set $v (i32.trunc_f64_s (call $get_float (i32.const 0) (i32.const 5))))
-//     (i32.store (i32.const 1024) (i32.or (local.get $v) (i32.const 0xFF000000))) ... the same at 1028, 1032, 1036
-//     (call $command (i32.const 16) (i32.const 7) (local.get $v) (i32.const 7))
-//     (i32.const 1024))
-constexpr std::array<std::uint8_t, 254> paint_module{
-	0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x12, 0x03, 0x60, 0x02, 0x7f, 0x7f, 0x01,
-	0x7c, 0x60, 0x04, 0x7f, 0x7f, 0x7f, 0x7f, 0x00, 0x60, 0x00, 0x01, 0x7f, 0x02, 0x21, 0x02, 0x04,
-	0x65, 0x75, 0x30, 0x37, 0x09, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x00, 0x00,
-	0x04, 0x65, 0x75, 0x30, 0x37, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x00, 0x01, 0x03,
-	0x04, 0x03, 0x02, 0x02, 0x02, 0x05, 0x03, 0x01, 0x00, 0x01, 0x07, 0x39, 0x04, 0x06, 0x6d, 0x65,
-	0x6d, 0x6f, 0x72, 0x79, 0x02, 0x00, 0x0c, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x77, 0x69,
-	0x64, 0x74, 0x68, 0x00, 0x02, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x68, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x00, 0x03, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x72, 0x65, 0x6e,
-	0x64, 0x65, 0x72, 0x00, 0x04, 0x0a, 0x5e, 0x03, 0x04, 0x00, 0x41, 0x02, 0x0b, 0x04, 0x00, 0x41,
-	0x02, 0x0b, 0x52, 0x01, 0x01, 0x7f, 0x41, 0x00, 0x41, 0x05, 0x10, 0x00, 0xaa, 0x21, 0x00, 0x41,
-	0x80, 0x08, 0x20, 0x00, 0x41, 0x80, 0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x84, 0x08,
-	0x20, 0x00, 0x41, 0x80, 0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x88, 0x08, 0x20, 0x00,
-	0x41, 0x80, 0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x8c, 0x08, 0x20, 0x00, 0x41, 0x80,
-	0x80, 0x80, 0x78, 0x72, 0x36, 0x02, 0x00, 0x41, 0x10, 0x41, 0x07, 0x20, 0x00, 0x41, 0x07, 0x10,
-	0x01, 0x41, 0x80, 0x08, 0x0b, 0x0b, 0x17, 0x02, 0x00, 0x41, 0x00, 0x0b, 0x05, 0x73, 0x70, 0x65,
-	0x65, 0x64, 0x00, 0x41, 0x10, 0x0b, 0x07, 0x63, 0x6d, 0x64, 0x74, 0x65, 0x73, 0x74};
-
-// "spin": exports the same functions as "paint", but screen_render never returns: (loop $l (br $l))
-constexpr std::array<std::uint8_t, 108> spin_module{
-	0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x05, 0x01, 0x60, 0x00, 0x01, 0x7f, 0x03,
-	0x04, 0x03, 0x00, 0x00, 0x00, 0x05, 0x03, 0x01, 0x00, 0x01, 0x07, 0x39, 0x04, 0x06, 0x6d, 0x65,
-	0x6d, 0x6f, 0x72, 0x79, 0x02, 0x00, 0x0c, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x77, 0x69,
-	0x64, 0x74, 0x68, 0x00, 0x00, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x68, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x00, 0x01, 0x0d, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x5f, 0x72, 0x65, 0x6e,
-	0x64, 0x65, 0x72, 0x00, 0x02, 0x0a, 0x15, 0x03, 0x04, 0x00, 0x41, 0x02, 0x0b, 0x04, 0x00, 0x41,
-	0x02, 0x0b, 0x09, 0x00, 0x03, 0x40, 0x0c, 0x00, 0x0b, 0x41, 0x00, 0x0b};
-
-// a texture that keeps what was uploaded to it
-struct recording_texture : ITexture {
-	bool create(bool) override { return true; }
-	int get_width() const override { return width; }
-	int get_height() const override { return height; }
-	size_t get_id() const override { return id; }
-	void release() override { /* nothing held */ }
-	void make_stub() override { /* nothing held */ }
-	std::string_view get_traits() const override { return ""; }
-	std::string_view get_name() const override { return "recording"; }
-	std::string_view get_type() const override { return "make:"; }
-	bool is_stub() const override { return false; }
-	bool get_has_alpha() const override { return true; }
-	bool get_is_ready() const override { return ready; }
-	void set_components_hint(int) override { /* not used */ }
-	void make_from_memory(size_t const Width, size_t const Height, const uint8_t *Data) override { update_from_memory(Width, Height, Data); }
-	void update_from_memory(size_t const Width, size_t const Height, const uint8_t *Data) override {
-		width = static_cast<int>(Width);
-		height = static_cast<int>(Height);
-		pixels.assign(Data, Data + Width * Height * 4);
-		++uploads;
-	}
-
-	bool ready{true};
-	size_t id{1};
-	int width{0};
-	int height{0};
-	int uploads{0};
-	std::vector<std::uint8_t> pixels;
-};
-
-// writes a module into a folder of its own, removed with the object
-class module_file {
-  public:
-	template <std::size_t Size_>
-	module_file(std::string const &Name, std::array<std::uint8_t, Size_> const &Bytes)
-	    : m_folder{std::filesystem::temp_directory_path() / std::format("eu07_wasm_test_{}", Name)} {
-		std::filesystem::create_directories(m_folder);
-		m_path = (m_folder / (Name + ".wasm")).generic_string();
-		std::ofstream file{m_path, std::ios::binary};
-		file.write(reinterpret_cast<char const *>(Bytes.data()), static_cast<std::streamsize>(Bytes.size()));
-	}
-	~module_file() {
-		std::error_code error;
-		std::filesystem::remove_all(m_folder, error);
-	}
-	module_file(module_file const &) = delete;
-	module_file &operator=(module_file const &) = delete;
-
-	std::string const &path() const { return m_path; }
-
-  private:
-	std::filesystem::path m_folder;
-	std::string m_path;
-};
-
-// runs frames until the condition holds, or gives up after a few seconds
-bool run_until(wasm_screen_queue &Queue, std::function<bool()> const &Condition) {
-	auto const deadline{std::chrono::steady_clock::now() + std::chrono::seconds(10)};
-	while (std::chrono::steady_clock::now() < deadline) {
-		Queue.update();
-		if (Condition()) {
-			return true;
-		}
-		std::this_thread::sleep_for(std::chrono::milliseconds(5));
-	}
-	return false;
-}
-
-std::shared_ptr<dictionary_source> speed(double const Value) {
-	auto input{std::make_shared<dictionary_source>()};
-	input->insert("speed", Value);
-	return input;
-}
-
-} // namespace
-
-TEST_CASE("wasm host: a cab screen draws from its input and sends commands to its vehicle") {
-	sent_commands().clear();
-	module_file const module{"paint", paint_module};
-	wasm_screen_queue queue;
-	REQUIRE(queue.init());
-
-	recording_texture texture;
-	auto const screen{queue.acquire({.kind = wasm_screen_kind::cab, .script = module.path(), .key = "cab", .texture = &texture, .frames = 0})};
-	REQUIRE(screen != nullptr);
-	// the same key, the same screen
-	CHECK(queue.acquire({.kind = wasm_screen_kind::cab, .script = module.path(), .key = "cab", .texture = &texture, .frames = 0}) == screen);
-
-	REQUIRE(run_until(queue, [&queue, &screen] { return queue.due(*screen); }));
-	queue.submit(screen, speed(5.0), 42);
-	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0 && false == sent_commands().empty(); }));
-
-	CHECK(texture.width == 2);
-	CHECK(texture.height == 2);
-	REQUIRE(texture.pixels.size() == 16);
-	std::array<std::uint8_t, 4> const expected{0x05, 0x00, 0x00, 0xFF};
-	for (std::size_t pixel = 0; pixel < 4; ++pixel) {
-		CAPTURE(pixel);
-		CHECK(std::equal(expected.begin(), expected.end(), texture.pixels.begin() + static_cast<std::ptrdiff_t>(pixel * 4)));
-	}
-
-	REQUIRE(sent_commands().size() == 1);
-	auto const &[command, recipient]{sent_commands().front()};
-	CHECK(command.command == user_command::aidriverenable);
-	CHECK(command.param1 == 5.0);
-	CHECK(command.param2 == 7.0);
-	CHECK(recipient == (static_cast<std::uint32_t>(command_target::vehicle) | 42u));
-
-	queue.exit();
-}
-
-TEST_CASE("wasm host: the image goes up again when the texture is made anew, and waits while it isn't there") {
-	sent_commands().clear();
-	module_file const module{"paint", paint_module};
-	wasm_screen_queue queue;
-	REQUIRE(queue.init());
-
-	recording_texture texture;
-	texture.ready = false;
-	auto const screen{queue.acquire({.kind = wasm_screen_kind::cab, .script = module.path(), .key = "cab", .texture = &texture, .frames = 0})};
-	REQUIRE(run_until(queue, [&queue, &screen] { return queue.due(*screen); }));
-	queue.submit(screen, speed(9.0), 1);
-	REQUIRE(run_until(queue, [] { return false == sent_commands().empty(); }));
-	queue.update();
-	CHECK(texture.uploads == 0);
-
-	texture.ready = true;
-	queue.update();
-	CHECK(texture.uploads == 1);
-	queue.update();
-	CHECK(texture.uploads == 1);
-
-	// released and made again: a new gl texture
-	texture.id = 2;
-	queue.update();
-	CHECK(texture.uploads == 2);
-
-	queue.exit();
-}
-
-TEST_CASE("wasm host: a screen outside the cab draws, but its commands are dropped") {
-	sent_commands().clear();
-	module_file const module{"paint", paint_module};
-	wasm_screen_queue queue;
-	REQUIRE(queue.init());
-
-	recording_texture texture;
-	auto const screen{queue.acquire({.kind = wasm_screen_kind::external, .script = module.path(), .key = "sign", .texture = &texture, .frames = 0})};
-	REQUIRE(run_until(queue, [&queue, &screen] { return queue.due(*screen); }));
-	queue.submit(screen, speed(3.0), 0);
-	REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
-	queue.update();
-	CHECK(sent_commands().empty());
-
-	queue.exit();
-}
-
-TEST_CASE("wasm host: a screen stuck in a loop is stopped, and the others keep working") {
-	sent_commands().clear();
-	module_file const spinning{"spin", spin_module};
-	module_file const painting{"paint", paint_module};
-	wasm_screen_queue queue;
-	REQUIRE(queue.init());
-
-	recording_texture stuck;
-	recording_texture working;
-	auto const first{queue.acquire({.kind = wasm_screen_kind::cab, .script = spinning.path(), .key = "spin", .texture = &stuck, .frames = 0})};
-	auto const second{queue.acquire({.kind = wasm_screen_kind::cab, .script = painting.path(), .key = "paint", .texture = &working, .frames = 0})};
-	REQUIRE(run_until(queue, [&queue, &first] { return queue.due(*first); }));
-	REQUIRE(run_until(queue, [&queue, &second] { return queue.due(*second); }));
-	queue.submit(first, speed(1.0), 1);
-	queue.submit(second, speed(2.0), 1);
-
-	REQUIRE(run_until(queue, [&working] { return working.uploads > 0; }));
-	CHECK(stuck.uploads == 0);
-	// the stuck screen ran first, into the instruction limit, and isn't due any more
-	CHECK_FALSE(queue.due(*first));
-
-	queue.exit();
-}
-
-TEST_CASE("wasm host: the screens outlive the queue without harm") {
-	module_file const module{"paint", paint_module};
-	std::shared_ptr<wasm_screen> screen;
-	recording_texture texture;
-	{
-		wasm_screen_queue queue;
-		REQUIRE(queue.init());
-		screen = queue.acquire({.kind = wasm_screen_kind::cab, .script = module.path(), .key = "cab", .texture = &texture, .frames = 0});
-		REQUIRE(run_until(queue, [&queue, &screen] { return queue.due(*screen); }));
-		queue.submit(screen, speed(4.0), 1);
-		REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
-	}
-	// the queue and the runtime are gone, the vehicle still holds its screen
-	CHECK(screen != nullptr);
-	screen.reset();
-}
-
-#endif
diff --git a/utilities/Globals.cpp b/utilities/Globals.cpp
index 6f27d631..0e622649 100644
--- a/utilities/Globals.cpp
+++ b/utilities/Globals.cpp
@@ -76,6 +76,10 @@ void global_settings::FinalizeConfig()
     wasm_enabled = false;
 #endif
 
+#ifndef WITH_LUA
+    luascreens_enabled = false;
+#endif
+
 #ifdef _WIN32
     Console::ModeSet(iFeedbackMode, iFeedbackPort);
 #endif
@@ -881,23 +885,30 @@ bool global_settings::ConfigParseUI(cParser& Parser, const std::string& token)
     return false;
 }
 
-bool global_settings::ConfigParseWasm(cParser& Parser, std::string_view const token)
+bool global_settings::ConfigParseScriptScreens(cParser& Parser, std::string_view const token)
 {
+    if (token == "luascreens.enabled")
+    {
+        ParseOne(Parser, luascreens_enabled, 1);
+        return true;
+    }
+
     if (token == "wasm.enabled")
     {
         ParseOne(Parser, wasm_enabled, 1);
         return true;
     }
 
-    if (token == "wasm.cabframes")
+    // wasm.cabframes and wasm.externalframes: the first names of the keys, from before the Lua screens
+    if (token == "screens.cabframes" || token == "wasm.cabframes")
     {
-        ParseOneClamped(Parser, wasm_cabframes, 1, 1000);
+        ParseOneClamped(Parser, screens_cabframes, 1, 1000);
         return true;
     }
 
-    if (token == "wasm.externalframes")
+    if (token == "screens.externalframes" || token == "wasm.externalframes")
     {
-        ParseOneClamped(Parser, wasm_externalframes, 1, 1000);
+        ParseOneClamped(Parser, screens_externalframes, 1, 1000);
         return true;
     }
 
@@ -1400,7 +1411,7 @@ void global_settings::ConfigParse(cParser& Parser)
         if (ConfigParsePython(Parser, token))
             continue;
 
-        if (ConfigParseWasm(Parser, token))
+        if (ConfigParseScriptScreens(Parser, token))
             continue;
 
         if (ConfigParseNetwork(Parser, token))
@@ -1870,9 +1881,10 @@ global_settings::export_as_text( std::ostream &Output ) const {
     export_as_text( Output, "python.threadedupload", python_threadedupload );
     export_as_text( Output, "python.uploadmain", python_uploadmain );
     export_as_text( Output, "python.mipmaps", python_mipmaps );
+    export_as_text( Output, "luascreens.enabled", luascreens_enabled );
     export_as_text( Output, "wasm.enabled", wasm_enabled );
-    export_as_text( Output, "wasm.cabframes", wasm_cabframes );
-    export_as_text( Output, "wasm.externalframes", wasm_externalframes );
+    export_as_text( Output, "screens.cabframes", screens_cabframes );
+    export_as_text( Output, "screens.externalframes", screens_externalframes );
     export_as_text( Output, "async.trainThreads", trainThreads );
     for( auto const &server : network_servers ) {
         Output
diff --git a/utilities/Globals.h b/utilities/Globals.h
index afa40e85..75df88bc 100644
--- a/utilities/Globals.h
+++ b/utilities/Globals.h
@@ -296,9 +296,10 @@ struct global_settings {
 	bool python_sharectx = true;
 	bool python_uploadmain = true;
 	std::chrono::duration<float> python_minframetime {0.01f};
+	bool luascreens_enabled{true}; // screens drawn by Lua scripts (luascreen:, luadestinationsign: in the .mmd)
 	bool wasm_enabled{true}; // screens drawn by WebAssembly modules (wasmscreen:, wasmdestinationsign: in the .mmd)
-	int wasm_cabframes{4}; // the wasm screens in the cab are refreshed every so many rendered frames
-	int wasm_externalframes{30}; // the wasm screens outside the cab (destination signs) are refreshed every so many rendered frames
+	int screens_cabframes{4}; // the script screens in the cab are refreshed every so many rendered frames
+	int screens_externalframes{30}; // the script screens outside the cab (destination signs) are refreshed every so many rendered frames
 
     bool gfx_skiprendering = false;
     int gfx_framebuffer_width = -1;
@@ -393,7 +394,7 @@ struct global_settings {
 	bool ConfigParseSimulation(cParser& Parser, const std::string& token);
 	bool ConfigParseUI(cParser& Parser, const std::string& token);
 	bool ConfigParsePython(cParser& Parser, const std::string& token);
-	bool ConfigParseWasm(cParser& Parser, std::string_view token);
+	bool ConfigParseScriptScreens(cParser& Parser, std::string_view token);
 	bool ConfigParseNetwork(cParser& Parser, const std::string& token);
 	bool ConfigParseHardware(cParser& Parser, const std::string& token);
 	bool ConfigParseDebug(cParser& Parser, const std::string& token);
diff --git a/vehicle/DynObj.cpp b/vehicle/DynObj.cpp
index 4842e5b1..192d73f2 100644
--- a/vehicle/DynObj.cpp
+++ b/vehicle/DynObj.cpp
@@ -298,6 +298,20 @@ material_data::assign( std::string const &Replacableskin ) {
 }
 
 
+namespace {
+
+// a luadestinationsign: or wasmdestinationsign: block, its script in the vehicle folder when it has no path of its own
+void deserialize_script_sign( cParser &Parser, script_screens::screen_config &Sign, std::string const &Folder ) {
+
+    Sign.deserialize( Parser );
+    if( false == Sign.script.empty()
+     && substr_path( Sign.script ).empty() ) {
+        Sign.script = Folder + Sign.script;
+    }
+}
+
+} // namespace
+
 void TDynamicObject::destination_data::deserialize( cParser &Input ) {
 
     while( true == deserialize_mapping( Input ) ) {
@@ -3141,19 +3155,19 @@ void TDynamicObject::update_destinations() {
 	                                         DestinationSign.destination :
 	                                         DestinationSign.destination_off;
 
-    update_wasm_destination();
+    update_script_destination();
 }
 
-void TDynamicObject::update_wasm_destination() {
+void TDynamicObject::update_script_destination() {
 
-    if( DestinationSign.wasm_sign == nullptr ) { return; }
+    if( DestinationSign.script_sign == nullptr ) { return; }
     // only while the sign shows the destination it draws
     if( m_materialdata.replacable_skins[ 4 ] != DestinationSign.destination ) { return; }
 
-    auto &queue { Application.wasm_screens() };
-    if( false == queue.due( *DestinationSign.wasm_sign ) ) { return; }
+    auto &queue { Application.screens() };
+    if( false == queue.due( *DestinationSign.script_sign ) ) { return; }
     // read anew on every refresh, so the sign follows the timetable
-    queue.submit( DestinationSign.wasm_sign, std::make_shared<dictionary_source>( DestinationSign.wasm_request ), 0 );
+    queue.submit( DestinationSign.script_sign, std::make_shared<dictionary_source>( DestinationSign.script_request ), 0 );
 }
 
 bool TDynamicObject::Update(double dt, double dt1)
@@ -7095,13 +7109,11 @@ void TDynamicObject::LoadMMediaFile( std::string const &TypeName, std::string co
                         DestinationSign.script = asBaseDir + DestinationSign.script;
                     }
                 }
+                else if( token == "luadestinationsign:" ) {
+                    deserialize_script_sign( parser, DestinationSign.lua, asBaseDir );
+                }
                 else if( token == "wasmdestinationsign:" ) {
-                    DestinationSign.wasm.deserialize( parser );
-                    // supply vehicle folder as script path if none is provided
-                    if( false == DestinationSign.wasm.script.empty()
-                     && substr_path( DestinationSign.wasm.script ).empty() ) {
-                        DestinationSign.wasm.script = asBaseDir + DestinationSign.wasm.script;
-                    }
+                    deserialize_script_sign( parser, DestinationSign.wasm, asBaseDir );
                 }
                 // NOTE: legacy key, now expected as optional "background:" parameter in pydestinationsign: { parameter block }
                 else if( token == "destinationsignbackground:" ) {
@@ -7122,9 +7134,12 @@ void TDynamicObject::LoadMMediaFile( std::string const &TypeName, std::string co
 
     if( ReplacableSkin != "none" ) {
         // potentially set blank destination texture
-        auto const wasmbackground { Global.wasm_enabled && false == DestinationSign.wasm.script.empty() && false == DestinationSign.wasm.background.empty() };
-        auto const &background { wasmbackground ? DestinationSign.wasm.background : DestinationSign.background };
+        auto language { script_language::lua };
+        auto const *scriptsign { script_destination( language ) };
+        auto const &background { ( scriptsign != nullptr && false == scriptsign->background.empty() ) ? scriptsign->background : DestinationSign.background };
         DestinationSign.destination_off = DestinationFind( background.empty() ? "nowhere" : background );
+        // a blank sign a script draws, drawn once
+        DestinationSign.background_sign = draw_script_texture( background, DestinationSign.destination_off );
     }
 
     // assign default samples to sound emitters which weren't included in the config file
@@ -7945,7 +7960,7 @@ void TDynamicObject::DestinationClear() {
     if( false == DestinationSign.has_light ) { return; } // physical destination signs remain up until manually changed
     // update_destinations() shows the blank sign in place of the missing destination
     DestinationSign.destination = null_handle;
-    DestinationSign.wasm_sign.reset();
+    DestinationSign.script_sign.reset();
 }
 
 void TDynamicObject::DestinationSet(std::string const &to, std::string const &numer) {
@@ -7960,7 +7975,7 @@ void TDynamicObject::DestinationSet(std::string const &to, std::string const &nu
     if( std::abs( m_materialdata.multi_textures ) >= 4 ) { return; } // jak są 4 tekstury wymienne, to nie zmieniać rozkładem
     if( DestinationSign.sign == nullptr )                { return; } // no sign submodel, no problem
     // a sign drawn for the previous destination
-    DestinationSign.wasm_sign.reset();
+    DestinationSign.script_sign.reset();
 
     // now see if we can find any version of the destination texture
     std::vector<std::string> const destinations = {
@@ -7976,7 +7991,7 @@ void TDynamicObject::DestinationSet(std::string const &to, std::string const &nu
         }
     }
     // if we didn't get static texture we might be able to make one
-    if( true == destination_set_wasm( numer ) ) { return; }
+    if( true == destination_set_script( numer ) ) { return; }
     if( DestinationSign.script.empty() ) { return; } // no script so no way to make the texture
     if( numer == "none" )                { return; } // blank or incomplete/malformed timetable, don't bother
 
@@ -8017,32 +8032,75 @@ std::string TDynamicObject::destination_request( std::string const &Script, std:
     return signrequest;
 }
 
-bool TDynamicObject::destination_set_wasm( std::string const &Numer ) {
+script_screens::screen_config const *TDynamicObject::script_destination( script_language &Language ) const {
 
-    if( false == Global.wasm_enabled )            { return false; }
-    if( DestinationSign.wasm.script.empty() )     { return false; } // no wasm sign, maybe a python one
-    if( Numer == "none" )                         { return false; } // blank or incomplete/malformed timetable, don't bother
+    auto const &screens { Application.screens() };
+    if( false == DestinationSign.lua.script.empty() && screens.runs( script_language::lua ) ) {
+        Language = script_language::lua;
+        return &DestinationSign.lua;
+    }
+    if( false == DestinationSign.wasm.script.empty() && screens.runs( script_language::wasm ) ) {
+        Language = script_language::wasm;
+        return &DestinationSign.wasm;
+    }
+    return nullptr; // no script sign, maybe a python one
+}
 
-    auto const signrequest { destination_request( DestinationSign.wasm.script, DestinationSign.wasm.instancing, DestinationSign.wasm.parameters ) };
+bool TDynamicObject::destination_set_script( std::string const &Numer ) {
+
+    if( Numer == "none" ) { return false; } // blank or incomplete/malformed timetable, don't bother
+    auto language { script_language::lua };
+    auto const *scriptsign { script_destination( language ) };
+    if( scriptsign == nullptr ) { return false; }
+
+    auto const signrequest { destination_request( scriptsign->script, scriptsign->instancing, scriptsign->parameters ) };
     auto const signmaterial { GfxRenderer->Fetch_Material( signrequest ) };
     if( signmaterial == null_handle ) { return false; }
     auto &signtexture { GfxRenderer->Texture( GfxRenderer->Material( signmaterial )->GetTexture( 0 ) ) };
 
     // vehicles showing the same request (one train, one instance) share the screen, as they share the texture
-    auto sign { Application.wasm_screens().acquire( {
-        .kind = wasm_screen_kind::external,
-        .script = DestinationSign.wasm.script,
+    auto sign { Application.screens().acquire( {
+        .kind = script_screen_kind::external,
+        .language = language,
+        .script = scriptsign->script,
         .key = signrequest,
         .texture = &signtexture,
-        .frames = DestinationSign.wasm.frames } ) };
-    if( sign == nullptr ) { return false; } // the wasm screens are off
+        .frames = scriptsign->frames } ) };
+    if( sign == nullptr ) { return false; }
 
     DestinationSign.destination = signmaterial;
-    DestinationSign.wasm_sign = std::move( sign );
-    DestinationSign.wasm_request = signrequest.substr( signrequest.find( '?' ) + 1 );
+    DestinationSign.script_sign = std::move( sign );
+    DestinationSign.script_request = signrequest.substr( signrequest.find( '?' ) + 1 );
     return true;
 }
 
+std::shared_ptr<script_screen> TDynamicObject::draw_script_texture( std::string const &Name, material_handle const Material ) {
+
+    if( false == Name.starts_with( "make:" ) || Material == null_handle ) { return nullptr; }
+    auto const query { Name.find( '?' ) };
+    auto const script { Name.substr( 5, query == std::string::npos ? std::string::npos : query - 5 ) };
+    auto const language { script_language_of( script ) };
+    if( false == language.has_value() ) { return nullptr; } // a python texture, made by the texture itself
+
+    auto &queue { Application.screens() };
+    auto &texture { GfxRenderer->Texture( GfxRenderer->Material( Material )->GetTexture( 0 ) ) };
+    auto screen { queue.acquire( {
+        .kind = script_screen_kind::external,
+        .language = *language,
+        .script = script,
+        .key = Name,
+        .texture = &texture,
+        .frames = 0 } ) };
+    if( screen == nullptr ) { return nullptr; }
+    queue.submit(
+        screen,
+        query == std::string::npos ?
+            std::make_shared<dictionary_source>() :
+            std::make_shared<dictionary_source>( Name.substr( query + 1 ) ),
+        0 );
+    return screen;
+}
+
 material_handle TDynamicObject::DestinationFind( std::string Destination ) {
 
     if( Destination.empty() ) { return null_handle; }
diff --git a/vehicle/DynObj.h b/vehicle/DynObj.h
index feaa548e..7475a22d 100644
--- a/vehicle/DynObj.h
+++ b/vehicle/DynObj.h
@@ -22,12 +22,13 @@ http://mozilla.org/MPL/2.0/.
 #include "audio/sound.h"
 #include "world/Spring.h"
 #include "vehicle/mirrors.h"
-#include "scripting/wasmscreenrules.h"
+#include "scripting/scriptscreenrules.h"
 
 #include <vector>
 #include <memory>
 
-class wasm_screen; // scripting/wasmscreens.h
+class script_screen; // scripting/scriptscreens.h
+enum class script_language; // scripting/scriptscreens.h
 
 #define EU07_SOUND_BOGIESOUNDS
 
@@ -255,9 +256,11 @@ public:
         int update_rate { 0 }; // -1: per stop, 0: none, >0: fps // TBD, TODO: implement?
         std::string instancing; // potential method to generate more than one texture per timetable
         std::string parameters; // potential extra parameters supplied by mmd file
-        wasm_screens::screen_config wasm; // potential WebAssembly sign (wasmdestinationsign:), used in place of the python one while wasm screens are on
-        std::shared_ptr<wasm_screen> wasm_sign; // the wasm screen drawing the current destination
-        std::string wasm_request; // its input: the key=value pairs a python sign gets for its texture
+        script_screens::screen_config lua; // potential Lua sign (luadestinationsign:), used in place of the python one while the Lua screens are on
+        script_screens::screen_config wasm; // potential WebAssembly sign (wasmdestinationsign:), likewise, when there's no Lua one
+        std::shared_ptr<script_screen> script_sign; // the script screen drawing the current destination
+        std::string script_request; // its input: the key=value pairs a python sign gets for its texture
+        std::shared_ptr<script_screen> background_sign; // the script screen which drew the blank sign, when a script draws it
     // methods
         void deserialize( cParser &Input );
     private:
@@ -733,8 +736,8 @@ private:
     void update_load_offset();
     void shuffle_load_order();
     void update_destinations();
-    // feeds the wasm destination sign with fresh data, when it is shown and due
-    void update_wasm_destination();
+    // feeds the script destination sign with fresh data, when it is shown and due
+    void update_script_destination();
     bool Update(double dt, double dt1);
     bool FastUpdate(double dt);
     void Move(double fDistance);
@@ -860,8 +863,12 @@ private:
     material_handle DestinationFind( std::string Destination );
     // the name of a generated destination sign texture: the script, the timetable, the instancing and the parameters
     std::string destination_request( std::string const &Script, std::string const &Instancing, std::string const &Parameters ) const;
-    // makes the destination sign a wasm screen, when the vehicle has one and the wasm screens are on. returns true when it did
-    bool destination_set_wasm( std::string const &Numer );
+    // the script sign of the vehicle the game can run: the Lua one, else the WebAssembly one; nullptr for none
+    script_screens::screen_config const *script_destination( script_language &Language ) const;
+    // makes the destination sign a script screen, when the vehicle has one the game can run. returns true when it did
+    bool destination_set_script( std::string const &Numer );
+    // draws a texture named make:<script>.lua?<parameters> (or .wasm) once with its script; nullptr for other textures
+    std::shared_ptr<script_screen> draw_script_texture( std::string const &Name, material_handle Material );
     void OverheadTrack(float o);
     glm::dvec3 get_future_movement() const;
 	void move_set(double distance);
diff --git a/vehicle/Train.cpp b/vehicle/Train.cpp
index 084e65d4..eef343fe 100644
--- a/vehicle/Train.cpp
+++ b/vehicle/Train.cpp
@@ -10038,7 +10038,7 @@ bool TTrain::Update(double const Deltatime)
 	if (!FreeFlyModeFlag && simulation::Train == this) // don't bother if we're outside
 	{
 		update_screens(Deltatime);
-		update_wasm_screens();
+		update_script_screens();
 	}
 
 	// update direction relay
@@ -10568,10 +10568,10 @@ void TTrain::update_screens(double dt)
 	}
 }
 
-void TTrain::update_wasm_screens()
+void TTrain::update_script_screens()
 {
-	auto &queue{Application.wasm_screens()};
-	for (auto &entry : m_wasmscreens)
+	auto &queue{Application.screens()};
+	for (auto &entry : m_scriptscreens)
 	{
 		if (false == queue.due(*entry.screen))
 		{
@@ -10606,10 +10606,10 @@ bool TTrain::find_screen_surface(std::string const &Target, std::string_view con
 	return true;
 }
 
-void TTrain::load_wasm_screen(cParser &Parser)
+void TTrain::load_script_screen(cParser &Parser, script_language const Language)
 {
-	wasm_screen_entry entry;
-	// the block is read whole even when the wasm screens are off
+	script_screen_entry entry;
+	// the block is read whole even when the script screens are off
 	entry.config.deserialize(Parser);
 	if (entry.config.script.empty())
 	{
@@ -10622,19 +10622,26 @@ void TTrain::load_wasm_screen(cParser &Parser)
 
 	TSubModel *submodel{nullptr};
 	ITexture *texture{nullptr};
-	if (entry.config.target != "none" && false == find_screen_surface(entry.config.target, "WASM Screen", submodel, texture))
+	auto &queue{Application.screens()};
+	if (false == queue.runs(Language))
+	{
+		// the screens of the language are off
+		return;
+	}
+	if (entry.config.target != "none" &&
+	    false == find_screen_surface(entry.config.target, Language == script_language::lua ? "Lua Screen" : "WASM Screen", submodel, texture))
 	{
 		return;
 	}
 
-	entry.screen = Application.wasm_screens().acquire({.kind = wasm_screen_kind::cab,
-	                                                   .script = entry.config.script,
-	                                                   .key = std::format("cab:{}:{}:{}", DynamicObject->name(), entry.config.target, entry.config.script),
-	                                                   .texture = texture,
-	                                                   .frames = entry.config.frames});
+	entry.screen = queue.acquire({.kind = script_screen_kind::cab,
+	                              .language = Language,
+	                              .script = entry.config.script,
+	                              .key = std::format("cab:{}:{}:{}", DynamicObject->name(), entry.config.target, entry.config.script),
+	                              .texture = texture,
+	                              .frames = entry.config.frames});
 	if (entry.screen == nullptr)
 	{
-		// the wasm screens are off
 		return;
 	}
 	if (texture != nullptr)
@@ -10651,7 +10658,7 @@ void TTrain::load_wasm_screen(cParser &Parser)
 	{
 		submodel->screen_touch_list = entry.touch_list;
 	}
-	m_wasmscreens.emplace_back(std::move(entry));
+	m_scriptscreens.emplace_back(std::move(entry));
 }
 
 void TTrain::add_distance(double const Distance)
@@ -10829,7 +10836,7 @@ bool TTrain::InitializeCab(int NewCabNo, std::string const &asFileName)
 	m_controlmapper.clear();
 	// clear python screens
 	m_screens.clear();
-	m_wasmscreens.clear();
+	m_scriptscreens.clear();
 	// reset sound positions
 	auto const nullvector{glm::vec3()};
 	std::vector<std::reference_wrapper<std::optional<sound_source>>> sounds = {
@@ -11051,9 +11058,13 @@ bool TTrain::InitializeCab(int NewCabNo, std::string const &asFileName)
 				if (Global.python_displaywindows)
 					m_screens.back().viewer = std::make_unique<python_screen_viewer>(rt, m_screens.back().touch_list, m_screens.back().script);
 			}
+			else if (token == "luascreen:")
+			{
+				load_script_screen(parser, script_language::lua);
+			}
 			else if (token == "wasmscreen:")
 			{
-				load_wasm_screen(parser);
+				load_script_screen(parser, script_language::wasm);
 			}
 			else if (token == "pyscreenupdatetime:")
 			{
diff --git a/vehicle/Train.h b/vehicle/Train.h
index 1d7e032c..82d8377d 100644
--- a/vehicle/Train.h
+++ b/vehicle/Train.h
@@ -19,7 +19,7 @@ http://mozilla.org/MPL/2.0/.
 #include "scripting/PyInt.h"
 #include "input/command.h"
 #include "scripting/pythonscreenviewer.h"
-#include "scripting/wasmscreens.h"
+#include "scripting/scriptscreens.h"
 #include "utilities/dictionary.h"
 
 #undef snprintf // pyint.h->python
@@ -146,11 +146,11 @@ class TTrain {
 
 	using screenentry_sequence = std::vector<screen_entry>;
 
-    // a screen of the cab drawn by a WebAssembly module (wasmscreen: in the .mmd)
-    struct wasm_screen_entry {
-        wasm_screens::screen_config config;
+    // a screen of the cab drawn by a script (luascreen:, wasmscreen: in the .mmd)
+    struct script_screen_entry {
+        script_screens::screen_config config;
         dictionary_source parameters; // the config's parameters, pre-processed
-        std::shared_ptr<wasm_screen> screen;
+        std::shared_ptr<script_screen> screen;
         std::shared_ptr<std::vector<glm::vec2>> touch_list;
     };
 
@@ -242,10 +242,10 @@ class TTrain {
     end cab_to_end() const {
         return cab_to_end( iCabn ); }
 	void update_screens(double dt);
-	void update_wasm_screens();
+	void update_script_screens();
 	// finds the submodel and the texture a cab screen is drawn on. returns false when the screen is to be ignored
 	bool find_screen_surface(std::string const &Target, std::string_view Kind, TSubModel *&Submodel, ITexture *&Texture) const;
-	void load_wasm_screen(cParser &Parser);
+	void load_script_screen(cParser &Parser, script_language Language);
 
     // command handlers
     // NOTE: we're currently using universal handlers and static handler map but it may be beneficial to have these implemented on individual class instance basis
@@ -948,7 +948,7 @@ private:
     bool m_mastercontrollerinuse { false };
     float m_mastercontrollerreturndelay { 0.f };
 	screenentry_sequence m_screens;
-	std::vector<wasm_screen_entry> m_wasmscreens;
+	std::vector<script_screen_entry> m_scriptscreens;
 	uint16_t vid { 0 }; // train network recipient id
     float m_distancecounter { -1.f }; // distance traveled since meter was activated or -1 if inactive
     double m_brakehandlecp{ 0.0 };
diff --git a/wasm_screens_doc.md b/wasm_screens_doc.md
deleted file mode 100644
index 494d07c0..00000000
--- a/wasm_screens_doc.md
+++ /dev/null
@@ -1,129 +0,0 @@
-# WebAssembly screens
-
-Screens drawn by WebAssembly modules, alongside the Python screens (`pyscreen:`, `pydestinationsign:`). A module
-gets the same input a Python screen gets (the table in `python_var_doc.md`), returns an RGBA image and, in the cab,
-may send commands. The modules run in the WAMR interpreter (`ref/wamr`), in a sandbox: a module reaches nothing but
-the functions of the `eu07` module below, and reads files only from its own folder.
-
-Unlike a Python screen, which refreshes after a time (`python.updatetime`, `updatetime:`), a WebAssembly screen
-refreshes every so many rendered frames, set in `eu07.ini`.
-
-## eu07.ini
-
-| key                   | default | meaning                                                                        |
-|-----------------------|---------|--------------------------------------------------------------------------------|
-| `wasm.enabled`        | 1       | 0: no WebAssembly screens; the vehicles show what they did before              |
-| `wasm.cabframes`      | 4       | a screen in the cab is refreshed every so many frames (1-1000)                 |
-| `wasm.externalframes` | 30      | a screen outside the cab (destination sign) is refreshed every so many frames  |
-
-A screen may ask for a longer interval of its own (`frames:` below); the longer of the two counts. Screens sharing
-an interval are spread over its frames, so they don't all refresh on the same one. A screen in the cab is refreshed
-only while the player sits in that cab, a screen outside only while its vehicle is drawn.
-
-## .mmd
-
-In the cab section, next to `pyscreen:`:
-
-```
-wasmscreen: { ekran.wasm target: screen01 frames: 6 parameters: id=1&mode=full }
-```
-
-| key           | meaning                                                                                           |
-|---------------|---------------------------------------------------------------------------------------------------|
-| (first token) | the module, relative to the vehicle folder when it has no path of its own                         |
-| `target:`     | the submodel the screen is drawn on (its texture is replaced); `none` for a screen that only sends commands |
-| `frames:`     | the screen's own refresh interval, used when longer than `wasm.cabframes`                         |
-| `parameters:` | extra `key=value` pairs, `&`-separated, added to the input                                        |
-
-A touch on the screen's submodel comes in the input as the list of points `touches`, as for the Python screens.
-
-In `internaldata:`, next to `pydestinationsign:`:
-
-```
-wasmdestinationsign: { tablica.wasm frames: 60 instance: name background: tablica_off parameters: style=lcd }
-```
-
-The keys are those of `pydestinationsign:` (`instance:`, `parameters:`, `background:`) and `frames:`. The input is
-what a Python sign gets: the timetable (`$timetable`), `_id1` (the train), `_id2` (the instance) and the
-parameters, read anew on every refresh, so the sign can follow the journey. The vehicles of one train showing the
-same request share one screen and one texture. A static destination texture, when there is one, still comes first.
-
-A vehicle may have both `pydestinationsign:` and `wasmdestinationsign:`: with the WebAssembly screens on, the
-WebAssembly one is used; with them off (or in a release without them) the Python one. An unknown key in either block
-is skipped together with its value.
-
-## The module
-
-Exports:
-
-| export                        | meaning                                                                                  |
-|-------------------------------|------------------------------------------------------------------------------------------|
-| `memory`                      | the linear memory                                                                        |
-| `screen_init() -> i32`        | optional; called once after loading. anything but 0 disables the screen                  |
-| `screen_render() -> i32`      | called on every refresh. returns the address of the image, or 0 to keep the previous one |
-| `screen_width() -> i32`       | the width of the image, asked after every `screen_render` that returned an image         |
-| `screen_height() -> i32`      | the height of the image, up to 4096 on either side                                       |
-
-The image is `width * height` pixels of 4 bytes, R G B A, in sRGB, its rows in the order the Python screens give
-them (PIL's `tobytes()`).
-
-Imports, module `eu07` (keys and texts are a pointer and a length in bytes, in the module's memory):
-
-| import                                                          | meaning                                                         |
-|-----------------------------------------------------------------|-----------------------------------------------------------------|
-| `value_type(key, key_len) -> i32`                               | 0 no such value, 1 float, 2 int, 3 bool, 4 string, 5 list of points |
-| `get_float(key, key_len) -> f64`                                | the value as a number (int and bool too); 0 when there is none  |
-| `get_int(key, key_len) -> i32`                                  | the value as an integer (a float is truncated)                   |
-| `get_bool(key, key_len) -> i32`                                 | 1 or 0                                                           |
-| `get_string(key, key_len, buffer, capacity) -> i32`             | copies the text, in UTF-8; returns its whole length, -1 when there is none |
-| `get_vec2_count(key, key_len) -> i32`                           | the number of points in a list (`touches`)                       |
-| `get_vec2(key, key_len, index, out) -> i32`                     | writes the point as two f32 at `out`; returns 1, or 0 when there is none |
-| `command(name, name_len, param1, param2)`                       | sends a command (the names of `simulation::commandMap`) to the vehicle of the cab; ignored outside the cab |
-| `log(text, text_len)`                                           | writes a line to the log                                         |
-| `time() -> f64`                                                 | seconds of a steady clock shared by all screens, for animations (scrolling) that keep their pace whatever the refresh interval |
-| `led_post(source, width, height, target, bloom) -> i32`         | `led_util.render_post()` of the Python screens, run natively: each diode of the `width x height` image becomes 2x2 pixels with a darker grid, glowing into its neighbours when `bloom` is not 0, in a 1 pixel black frame; `target` takes `(2 width + 2) x (2 height + 2)`. returns 1, or 0 for sizes over 4096 |
-| `resize_lanczos(source, width, height, target, target_width, target_height) -> i32` | Pillow's `resize(..., Image.LANCZOS)`, run natively, giving the same pixels. returns 1, or 0 for sizes over 4096 |
-| `file_read(path, path_len, buffer, capacity) -> i32`            | reads a file from the module's folder or below; returns the file's whole size, -1 when there is none or the path leads outside |
-
-`led_post` and `resize_lanczos` take RGBA images in the module's memory and write alpha 255; the source and the
-target may overlap. They are what makes LED boards fast enough: in the interpreter the same filters take some 30
-times longer.
-
-A call into the module may run at most 200 million instructions; a module that traps or runs over is disabled and
-the reason goes to the log. The module gets 64 KiB of stack and no heap from the host: it manages its own memory.
-
-## Building a module
-
-With clang (any version with the `wasm32` target), no C library:
-
-```c
-// ekran.c
-#include <stdint.h>
-
-#define IMPORT(name) __attribute__((import_module("eu07"), import_name(name)))
-IMPORT("get_float") double get_float(const char *key, int key_len);
-IMPORT("command") void command(const char *name, int name_len, int param1, int param2);
-
-#define WIDTH 256
-#define HEIGHT 128
-static uint32_t pixels[WIDTH * HEIGHT];
-
-__attribute__((export_name("screen_width"))) int screen_width(void) { return WIDTH; }
-__attribute__((export_name("screen_height"))) int screen_height(void) { return HEIGHT; }
-
-__attribute__((export_name("screen_render"))) int screen_render(void) {
-	double const velocity = get_float("velocity", 8);
-	int const filled = (int)(velocity * WIDTH / 160.0);
-	for (int y = 0; y < HEIGHT; ++y)
-		for (int x = 0; x < WIDTH; ++x)
-			pixels[y * WIDTH + x] = x < filled ? 0xFF00C000u : 0xFF202020u; // A B G R, little-endian
-	return (int)(uintptr_t)pixels;
-}
-```
-
-```
-clang --target=wasm32 -O2 -nostdlib -Wl,--no-entry -o ekran.wasm ekran.c
-```
-
-Any language that compiles to WebAssembly works the same way (Rust `wasm32-unknown-unknown`, Zig, AssemblyScript),
-as long as the module imports nothing but the `eu07` functions above.