Write it like BASIC. Ship it like C.

// A boss fight as a coroutine: each phase is a few lines that wait, and the game's
// frame loop ticks a Scheduler of its own, 60 times a second, so pausing it pauses the fight.
Import std.core
Import std.time

Class Boss
    Field name: String
    Field hp: Int = 300

    New(name: String)
        Self.name = name
    End New
End Class

Global frame = 0

Function Say(text: String)
    Print("frame {frame}: {text}")
End Function

Async Function Fight(boss: Boss)
    Say("{boss.name} wakes up")
    Await Wait(1.Seconds)
    While boss.hp > 150
        Say("{boss.name} swings its hammer ({boss.hp} hp)")
        Await Wait(750.Milliseconds)
    End While
    Say("{boss.name} is angry, and twice as fast")
    While boss.hp > 0
        Await Wait(375.Milliseconds)
    End While
    Say("{boss.name} falls")
End Function

Local boss = Boss("The Warden")
Local gameplay = Scheduler()
gameplay.Run(Fight(boss))
While !gameplay.IsIdle()
    frame += 1
    If frame % 20 == 0 Then boss.hp -= 20     // the player lands a hit
    gameplay.Tick(1.0 / 60.0)
End While
Say("the fight took {frame} frames")

frame 0: The Warden wakes up
frame 60: The Warden swings its hammer (240 hp)
frame 105: The Warden swings its hammer (200 hp)
frame 150: The Warden swings its hammer (160 hp)
frame 195: The Warden is angry, and twice as fast
frame 310: The Warden falls
frame 310: the fight took 310 frames

// A save file in JSON: Json.Write saves a Struct field by field, and Json.Read<T> loads
// it back, so the save format is the type itself.
Import std.core
Import std.data
Import std.io

Struct SaveGame
    Field player: String
    Field level: Int
    Field gold: Int
    Field items: String[]
End Struct

Local game = SaveGame("Ada", 3, 120, ["lamp", "rope", "old key"])
Try File.WriteText("save.json", Json.Write(game, 2))
Print(Try File.ReadText("save.json"))

Local loaded = Try Json.Read<SaveGame>(Try File.ReadText("save.json"))
Print("{loaded.player} is on level {loaded.level}, carrying {loaded.items.Count} things")

{
  "player": "Ada",
  "level": 3,
  "gold": 120,
  "items": [
    "lamp",
    "rope",
    "old key"
  ]
}
Ada is on level 3, carrying 3 things

// Heavy work on another thread: Spawn runs a Function on the worker pool and gives a Task,
// and the main thread goes on until it needs the result.
Import std.core

Function CountPrimes(below: Int): Int
    Local count = 0
    For n = 2 Until below
        Local d = 2
        While d * d <= n && n % d != 0
            d += 1
        End While
        If d * d > n Then count += 1
    End For
    Return count
End Function

Local task = Spawn(Function() => CountPrimes(300_000))
Print("the worker is counting; the main thread draws the loading screen")
Print("primes below 300,000: {task.Wait()}")

the worker is counting; the main thread draws the loading screen
primes below 300,000: 25997

// Particles over every core: each frame, a Parallel For steps them in chunks on the worker
// pool. Its iterations touch only their own particle, which the compiler checks.
Import std.core
Import std.math

Struct Particle
    Field pos: Vec2
    Field vel: Vec2

    ByRef Method Step(dt: Float)
        vel = vel + Vec2(0, -9.8) * dt
        pos = pos + vel * dt
    End Method
End Struct

Local particles: Particle[] = []
For i = 0 Until 100_000
    particles.Add(Particle(Vec2(0, 0), Vec2((i % 21 - 10) As Float * 0.5, 12)))
End For

For frame = 1 To 60
    Parallel For i = 0 Until particles.Count
        particles[i].Step(1.0 / 60.0)
    End For
End For

Print("{particles.Count} particles after one second")
Print("the first is at {particles[0].pos}, the eleventh at {particles[10].pos}")

100000 particles after one second
the first is at (-5, 7.01834), the eleventh at (0, 7.01834)

// A window from a C library: raylib's own functions, declared in an Extern block and called
// as FutureBlitz Functions. project.toml's [native] links raylib, which has to be installed.
Import std.core

@CLayout Struct Color
    Field r: UInt8
    Field g: UInt8
    Field b: UInt8
    Field a: UInt8
End Struct

Extern "C" Lib "raylib"
    Function InitWindow(width: Int, height: Int, title: CString)
    Function WindowShouldClose(): Bool
    Function BeginDrawing()
    Function EndDrawing()
    Function ClearBackground(color: Color)
    Function DrawText(text: CString, x: Int, y: Int, size: Int, color: Color)
    Function SetTargetFPS(fps: Int)
    Function CloseWindow()
End Extern

Const NIGHT = Color(8, 9, 13, 255)
Const AMBER = Color(242, 165, 58, 255)

InitWindow(800, 450, "FutureBlitz and raylib")
SetTargetFPS(60)
While !WindowShouldClose()
    BeginDrawing()
    ClearBackground(NIGHT)
    DrawText("Hello from FutureBlitz", 190, 200, 40, AMBER)
    EndDrawing()
End While
CloseWindow()

This one opens an 800 by 450 window, so the site's build checks it with fb check and doesn't run it. Running it needs raylib installed.