Fix wget using obsolete file and HTTP Lua methods

Signed-off-by: Alessandro Proto <alex@alexdevs.me>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -30,9 +30,9 @@ A clear and concise description of what you expected to happen.
 If applicable, add screenshots to help explain your problem.
 
 **Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
+ - OS: [e.g. Linux, Windows, OSX]
+ - OS Version: [e.g. 22]
+ - Capy64 Version: [e.g. 0.0.9-alpha]
 
 **Additional context**
 Add any other context about the problem here.

.github/workflows/dotnet.yml

@@ -5,42 +5,59 @@ name: .NET
 
 on:
   push:
-    branches: [ "main" ]
+    branches: ["main"]
   pull_request:
-    branches: [ "main" ]
+    branches: ["main"]
 
 jobs:
-  build:
+  build-windows:
+    runs-on: windows-latest
 
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+      - name: Restore dependencies
+        run: dotnet restore
+      - name: Build
+        run: dotnet build --no-restore
+      - name: Test
+        run: dotnet test --no-build --verbosity normal
+
+      - name: Publish for Windows x64
+        run: dotnet publish Capy64/Capy64.csproj -c Release --no-self-contained -a x64 --os win -p:PublishSingleFile=true -o publish/win-x64
+
+      - name: Upload Windows x64 artifact
+        uses: actions/upload-artifact@v3.1.2
+        with:
+          name: Windows-x64
+          path: publish/win-x64/**
+          if-no-files-found: error
+
+  build-linux:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v3
-      with:
-        dotnet-version: 7.0.x
-    - name: Restore dependencies
-      run: dotnet restore
-    - name: Build
-      run: dotnet build --no-restore
-    - name: Test
-      run: dotnet test --no-build --verbosity normal
-      
-    - name: Publish for Linux x64
-      run: dotnet publish Capy64/Capy64.csproj -c Release --no-self-contained -a x64 --os linux -p:PublishSingleFile=true -o publish/linux-x64
-    - name: Publish for Windows x64
-      run: dotnet publish Capy64/Capy64.csproj -c Release --no-self-contained -a x64 --os win -p:PublishSingleFile=true -o publish/win-x64
-      
-    - name: Upload Linux x64 artifact
-      uses: actions/upload-artifact@v3.1.2
-      with:
-        name: Linux-x64
-        path: publish/linux-x64/**
-        if-no-files-found: error
-    - name: Upload Windows x64 artifact
-      uses: actions/upload-artifact@v3.1.2
-      with:
-        name: Windows-x64
-        path: publish/win-x64/**
-        if-no-files-found: error
+      - uses: actions/checkout@v3
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+      - name: Restore dependencies
+        run: dotnet restore
+      - name: Build
+        run: dotnet build --no-restore
+      - name: Test
+        run: dotnet test --no-build --verbosity normal
+
+      - name: Publish for Linux x64
+        run: dotnet publish Capy64/Capy64.csproj -c Release --no-self-contained -a x64 --os linux -p:PublishSingleFile=true -o publish/linux-x64
+
+      - name: Upload Linux x64 artifact
+        uses: actions/upload-artifact@v3.1.2
+        with:
+          name: Linux-x64
+          path: publish/linux-x64/**
+          if-no-files-found: error

.github/workflows/main.yml

@@ -1,69 +0,0 @@
-name: Publish release draft
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: Release tag
-        required: true
-      prerelease:
-        description: Prerelease
-        type: boolean
-      generatenotes:
-        description: Generate release notes
-        type: boolean
-      
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    
-    steps:
-    - uses: actions/checkout@v3
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v3
-      with:
-        dotnet-version: 7.0.x
-    - name: Restore dependencies
-      run: dotnet restore
-    - name: Build
-      run: dotnet build --no-restore
-    - name: Test
-      run: dotnet test --no-build --verbosity normal
-      
-    - name: Publish for Linux x64
-      run: dotnet publish Capy64/Capy64.csproj -c Release --no-self-contained -a x64 --os linux -p:PublishSingleFile=true -o publish/linux-x64
-    - name: Publish for Windows x64
-      run: dotnet publish Capy64/Capy64.csproj -c Release --no-self-contained -a x64 --os win -p:PublishSingleFile=true -o publish/win-x64
-      
-    - name: Upload Linux x64 artifact
-      uses: actions/upload-artifact@v3.1.2
-      with:
-        name: Linux-x64
-        path: publish/linux-x64/**
-        if-no-files-found: error
-    - name: Upload Windows x64 artifact
-      uses: actions/upload-artifact@v3.1.2
-      with:
-        name: Windows-x64
-        path: publish/win-x64/**
-        if-no-files-found: error
-        
-    - name: Zip Linux x64
-      run: 7z a capy64-linux-x64.zip publish/linux-x64/**
-    - name: Zip Windows x64
-      run: 7z a capy64-windows-x64.zip publish/win-x64/**
-      
-    - name: Create Release
-      uses: ncipollo/release-action@v1.12.0
-      with:
-        commit: ${{ github.ref_name }}
-        tag: ${{ inputs.tag }}
-        allowUpdates: true
-        artifactErrorsFailBuild: true
-        artifacts: "capy64-linux-x64.zip,capy64-windows-x64.zip"
-        draft: true
-        generateReleaseNotes: ${{ inputs.generatenotes }}
-        makeLatest: true
-        prerelease: ${{ inputs.prerelease }}

.github/workflows/publish.yml

@@ -0,0 +1,97 @@
+name: Publish release draft
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Release tag
+        required: true
+      prerelease:
+        description: Prerelease
+        type: boolean
+      generatenotes:
+        description: Generate release notes
+        type: boolean
+
+jobs:
+  release-windows:
+    runs-on: windows-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+      - name: Restore dependencies
+        run: dotnet restore
+      - name: Build
+        run: dotnet build --no-restore
+      - name: Test
+        run: dotnet test --no-build --verbosity normal
+
+      - name: Publish for Windows x64
+        run: dotnet publish Capy64/Capy64.csproj -c Release -a x64 --os win -p:PublishReadyToRun=false -p:PublishSingleFile=true -p:TieredCompilation=false -o capy64-windows-x64 --self-contained
+
+      - name: Upload Windows x64 artifact
+        uses: actions/upload-artifact@v3.1.2
+        with:
+          name: Windows-x64
+          path: capy64-windows-x64/**
+          if-no-files-found: error
+
+      - name: Zip Windows x64
+        run: 7z a capy64-windows-x64.zip capy64-windows-x64/**
+
+  release-linux:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+      - name: Restore dependencies
+        run: dotnet restore
+      - name: Build
+        run: dotnet build --no-restore
+      - name: Test
+        run: dotnet test --no-build --verbosity normal
+
+      - name: Publish for Linux x64
+        run: dotnet publish Capy64/Capy64.csproj -c Release -a x64 --os linux -p:PublishReadyToRun=false -p:PublishSingleFile=true -p:TieredCompilation=false -o capy64-linux-x64 --self-contained
+
+      - name: Upload Linux x64 artifact
+        uses: actions/upload-artifact@v3.1.2
+        with:
+          name: Linux-x64
+          path: capy64-linux-x64/**
+          if-no-files-found: error
+
+      - name: Zip Linux x64
+        run: 7z a capy64-linux-x64.zip capy64-linux-x64/**
+
+  publish:
+    needs: [release-windows, release-linux]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Create Release
+        uses: ncipollo/release-action@v1.12.0
+        with:
+          commit: ${{ github.ref_name }}
+          tag: ${{ inputs.tag }}
+          allowUpdates: true
+          artifactErrorsFailBuild: true
+          artifacts: "capy64-linux-x64.zip,capy64-windows-x64.zip"
+          draft: true
+          generateReleaseNotes: ${{ inputs.generatenotes }}
+          makeLatest: true
+          prerelease: ${{ inputs.prerelease }}

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+capy64@alexdevs.me.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

Capy64/.config/dotnet-tools.json

@@ -1,36 +0,0 @@
-{
-  "version": 1,
-  "isRoot": true,
-  "tools": {
-    "dotnet-mgcb": {
-      "version": "3.8.1.303",
-      "commands": [
-        "mgcb"
-      ]
-    },
-    "dotnet-mgcb-editor": {
-      "version": "3.8.1.303",
-      "commands": [
-        "mgcb-editor"
-      ]
-    },
-    "dotnet-mgcb-editor-linux": {
-      "version": "3.8.1.303",
-      "commands": [
-        "mgcb-editor-linux"
-      ]
-    },
-    "dotnet-mgcb-editor-windows": {
-      "version": "3.8.1.303",
-      "commands": [
-        "mgcb-editor-windows"
-      ]
-    },
-    "dotnet-mgcb-editor-mac": {
-      "version": "3.8.1.303",
-      "commands": [
-        "mgcb-editor-mac"
-      ]
-    }
-  }
-}

Capy64/API/IComponent.cs

@@ -14,13 +14,10 @@
 // limitations under the License.
 
 using KeraLua;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace Capy64.API;
 
 public interface IComponent
 {
-    void ConfigureServices(IServiceCollection services) { }
     void LuaInit(Lua L) { }
-
 }

Capy64/Assets/Lua/CapyOS/home/.shrc

@@ -0,0 +1,7 @@
+alias ll "ls -al"
+alias la "ls -a"
+alias rmdir "rm -r"
+alias reboot "shutdown -r"
+
+# Comment or remove the line below to disable the MOTD
+motd

Capy64/Assets/Lua/CapyOS/init.lua

@@ -0,0 +1,46 @@
+local version = "0.1.1"
+local systemDirectory = "/sys"
+
+print("Starting CapyOS")
+
+local term = require("term")
+local fs = require("fs")
+local machine = require("machine")
+
+local nPrint = print
+local function showError(err)
+    nPrint(err)
+    local x, y = term.getPos()
+    term.setForeground(0xff0000)
+    term.setPos(1, y)
+    term.write(err)
+
+    term.setPos(1, y + 1)
+    term.setForeground(0xffffff)
+    term.write("Press any key to continue")
+
+    coroutine.yield("key_down")
+end
+
+function os.version()
+    return "CapyOS " .. version
+end
+
+term.setPos(1, 1)
+term.write(machine.version())
+term.setPos(1, 3)
+
+local files = fs.list(fs.combine(systemDirectory, "boot/autorun"))
+for i = 1, #files do
+    local func, err = loadfile(fs.combine(systemDirectory, "boot/autorun", files[i]))
+    if not func then
+        showError(err)
+        break
+    end
+
+    local ok, err = pcall(func)
+    if not ok then
+        showError(debug.traceback(err))
+        break
+    end
+end

Capy64/Assets/Lua/CapyOS/sys/bin/alias.lua

@@ -0,0 +1,28 @@
+local argparser = require("argparser")
+
+local args, options = argparser.parse(...)
+
+
+if options.l or options.list then
+    for alias, value in pairs(shell.aliases) do
+        print(string.format("%s = \"%s\"", alias, value))
+    end
+    return
+end
+
+local alias = args[1]
+
+if not alias or options.h or options.help then
+    print("Usage: alias [option...] <alias> [command]")
+    print("Options:")
+    print(" -l --list: List aliases")
+    return false
+end
+
+local command = table.pack(select(2, ...))
+if #command == 0 then
+    shell.aliases[alias] = nil
+    return
+end
+
+shell.aliases[alias] = table.concat(command, " ")

Capy64/Assets/Lua/CapyOS/sys/bin/bg.lua

@@ -0,0 +1,4 @@
+local scheduler = require("scheduler")
+scheduler.spawn(function()
+    shell.run(arg.string)
+end)

Capy64/Assets/Lua/CapyOS/sys/bin/cat.lua

@@ -0,0 +1,9 @@
+local fs = require("fs")
+
+local args = {...}
+
+local path = shell.resolve(args[1])
+
+local f<close> = fs.open(path, "r")
+print(f:read("a"))
+f:close()

Capy64/Assets/Lua/CapyOS/sys/bin/cd.lua

@@ -0,0 +1,17 @@
+local args = {...}
+local fs = require("fs")
+
+local dir = args[1]
+
+if not dir then
+    dir = shell.homePath
+end
+
+dir = shell.resolve(dir)
+
+if not fs.isDir(dir) then
+    error("No such directory: " .. dir, 0)
+    return false
+end
+
+shell.setDir(dir)

Capy64/Assets/Lua/CapyOS/sys/bin/clear.lua

@@ -0,0 +1,5 @@
+local term = require("term")
+local colors = require("colors")
+term.setBackground(colors.black)
+term.clear()
+term.setPos(1, 1)

Capy64/Assets/Lua/CapyOS/sys/bin/echo.lua

@@ -0,0 +1,4 @@
+local argparser = require("argparser")
+
+local args, options = argparser.parse(...)
+print(table.concat(args, " "))

Capy64/Assets/Lua/CapyOS/sys/bin/exit.lua

@@ -0,0 +1 @@
+shell.exit()

Capy64/Assets/Lua/CapyOS/sys/bin/fun/donuts.lua

@@ -0,0 +1,40 @@
+local gpu = require("gpu")
+local event = require("event")
+local donuts = {}
+local limit = 100
+
+local w, h = gpu.getSize()
+local function insert()
+    local donut = {
+        x = math.random(-20, w + 20),
+        y = math.random(-20, h + 20),
+        d = math.random() * math.pi*2,
+        dir = math.random(0, 1),
+        c = math.random(0xffffff),
+        life = math.random(100, 1000),
+    }
+    table.insert(donuts, donut)
+end
+
+while true do
+    if #donuts < limit then
+        insert()
+    end
+    gpu.clear(0)
+    for k, donut in ipairs(donuts) do
+        if donut.life <= 0 then
+            table.remove(donuts, k)
+        end
+        local doReverse = math.random(0, 1000) > 950
+        donut.x = donut.x + math.cos(donut.d) * 4
+        donut.y = donut.y + math.sin(donut.d) * 4
+        donut.d = donut.d + (donut.dir == 1 and 0.05 or -0.05)
+        gpu.drawCircle(donut.x, donut.y, 20, donut.c, 10)
+        if doReverse then
+            donut.dir = donut.dir == 1 and 0 or 1
+        end
+        donut.life = donut.life - 1
+    end
+    event.push("donuts")
+    event.pull("donuts")
+end

Capy64/Assets/Lua/CapyOS/sys/bin/fun/mandelbrot.lua

@@ -0,0 +1,98 @@
+-- Mandelbrot in Capy64
+
+local gpu = require("gpu")
+local timer = require("timer")
+local event = require("event")
+local term = require("term")
+
+-- lower = closer = slower
+local scale = 4
+
+-- higher = more detailed = slower
+local iterations = 100
+
+local pscale = scale
+local w, h = gpu.getSize()
+local px = pscale / w
+local colorUnit = math.floor(0xffffff / iterations)
+-- todo: make it interactive
+local dx, dy = 0, 0
+local cx, cy = math.floor(w / 2), math.floor(h / 2)
+
+-- z = z^2 + c
+local function mandelbrot(zr, zi, cr, ci)
+    return zr ^ 2 - zi ^ 2 + cr,
+        2 * zr * zi + ci
+end
+
+local function iter(cr, ci)
+    local zr, zi = 0, 0
+    for i = 1, iterations do
+        zr, zi = mandelbrot(zr, zi, cr, ci)
+        if math.abs(zr) >= (pscale >= 2 and pscale or 2) or math.abs(zi) >= (pscale >= 2 and pscale or 2) then
+            return false, colorUnit, i
+        end
+    end
+
+    return true, 0, iterations
+end
+
+local function draw()
+    local size = w * h
+    local canvas = { string.unpack(("B"):rep(size), ("\0"):rep(size)) }
+    canvas[#canvas] = nil
+
+
+    for y = 0, h - 1 do
+        for x = 0, w - 1 do
+            local _, _, i = iter((x - cx + dx * pscale) * px, (y - cy + dy * pscale) * px)
+            canvas[y * w + x] = colorUnit * (iterations - i)
+        end
+    end
+
+    local buffer <close> = gpu.bufferFrom(canvas, w, h)
+    gpu.setBuffer(buffer)
+end
+
+-- no idea why it's needed
+timer.sleep(0)
+
+draw()
+
+local tw, th = term.getSize()
+
+while true do
+    term.setPos(1, th)
+    term.setBackground(0)
+    term.setForeground(0xffffff)
+    term.write("X: " .. dx .. "; Y: " .. dy .. "; S: " .. pscale .. "; " .. px .. "!")
+    local ev = { event.pull("key_down") }
+    if ev[1] == "key_down" then
+        local key = ev[3]
+        if key == "up" then
+            dy = dy - 10 / pscale
+        elseif key == "down" then
+            dy = dy + 10 / pscale
+        elseif key == "right" then
+            dx = dx + 10 / pscale
+        elseif key == "left" then
+            dx = dx - 10 / pscale
+        elseif key == "enter" then
+            draw()
+        elseif key == "page_down" then
+            pscale = pscale * 1.25
+            dx = dx * pscale
+            dy = dy * pscale
+        elseif key == "page_up" then
+            pscale = pscale / 1.25
+            dx = dx / pscale
+            dy = dy / pscale
+        elseif key == "r" then
+            pscale = scale
+            dx = 0
+            dy = 0
+        end
+    end
+
+    px = pscale / w
+end

Capy64/Assets/Lua/CapyOS/sys/bin/fun/melt.lua

@@ -0,0 +1,73 @@
+local gpu = require("gpu")
+local timer = require("timer")
+local event = require("event")
+local colors = require("colors")
+local parallel = require("parallel")
+
+local melts = 2 ^ 12
+
+local function contains(arr, val)
+    for k, v in ipairs(arr) do
+        if v == val then
+            return true
+        end
+    end
+    return false
+end
+
+local function melt()
+    local w, h = gpu.getSize()
+    local x, y = 0, 0
+
+    while true do
+        local buffer <close> = gpu.getBuffer()
+        for i = 1, melts do
+            local nx = math.random(x, w)
+            local ny = math.random(y, h)
+
+            local c = buffer[ny * w + nx]
+            buffer[(ny + 1) * w + nx] = c
+        end
+        gpu.setBuffer(buffer)
+
+        timer.delay(0):await()
+    end
+end
+
+local function draw()
+    local ox, oy
+    while true do
+        local ev, b, x, y = event.pull("mouse_move", "mouse_down")
+
+        if ev == "mouse_down" then
+            if b == 1 then
+                ox = x
+                oy = y
+            end
+        elseif ev == "mouse_move" then
+            if contains(b, 1) then
+                gpu.plot(x, y, colors.red)
+                gpu.drawLine(x, y, ox, oy, colors.red)
+                ox, oy = x, y
+            end
+        end
+    end
+end
+
+local function random()
+    local w, h = gpu.getSize()
+    while true do
+        for i = 1, 24 do
+            gpu.drawString(
+                math.random(-7, w),
+                math.random(-13, h),
+                math.random(0, 0xffffff),
+                string.char(math.random(32, 127))
+            )
+        end
+
+        timer.delay(0.1):await()
+    end
+end
+
+parallel.waitForAny(draw, melt, random)

Capy64/Assets/Lua/CapyOS/sys/bin/fun/paint.lua

@@ -0,0 +1,209 @@
+local event = require("event")
+local gpu = require("gpu")
+local colors = require("colors")
+local term = require("term")
+local timer = require("timer")
+
+local w, h = gpu.getSize()
+local tw, th = term.getSize()
+
+local selectedColor = 1
+local thickness = 4
+
+local canvasW, canvasH = term.toRealPos(tw - 1, th + 1)
+canvasW = canvasW - 3
+local size = canvasW * canvasH
+local canvas = {string.unpack(("B"):rep(size), ("\0"):rep(size))}
+canvas[#canvas] = nil
+
+local function drawCircle(buffer, x, y, radius, color)
+    radius = math.max(0, radius)
+    if radius == 0 then
+        buffer[x + buffer.width * y] = color
+        return
+    end
+    local width = buffer.width
+    local height = buffer.height
+
+    local index = function(x, y)
+        return y * width + x
+    end
+
+    local isValid = function(x, y)
+        return x >= 0 and x < width and y >= 0 and y < height
+    end
+
+    local setPixel = function(x, y, color)
+        if isValid(x, y) then
+            buffer[index(x, y)] = color
+        end
+    end
+
+    local drawFilledCirclePoints = function(cx, cy, x, y)
+        for dx = -x, x do
+            for dy = -y, y do
+                setPixel(cx + dx, cy + dy, color)
+            end
+        end
+    end
+
+    local drawCircleBresenham = function(cx, cy, radius)
+        local x = 0
+        local y = radius
+        local d = 3 - 2 * radius
+        drawFilledCirclePoints(cx, cy, x, y)
+        while y >= x do
+            x = x + 1
+            if d > 0 then
+                y = y - 1
+                d = d + 4 * (x - y) + 10
+            else
+                d = d + 4 * x + 6
+            end
+            drawFilledCirclePoints(cx, cy, x, y)
+        end
+    end
+
+    drawCircleBresenham(x, y, radius)
+end
+
+local function drawLine(buffer, x0, y0, x1, y1, color, thickness)
+    local width = canvasW
+    local height = canvasH
+
+    local index = function(x, y)
+        return y * width + x
+    end
+
+    local isValid = function(x, y)
+        return x >= 0 and x < width and y >= 0 and y < height
+    end
+
+    local setPixel = function(x, y)
+        if isValid(x, y) then
+            buffer[index(x, y)] = color
+        end
+    end
+
+    local drawLineBresenham = function()
+        local i = 0
+        local dx = math.abs(x1 - x0)
+        local dy = math.abs(y1 - y0)
+        local sx = x0 < x1 and 1 or -1
+        local sy = y0 < y1 and 1 or -1
+        local err = dx - dy
+
+        local majorAxis = dx > dy
+
+        while x0 ~= x1 or y0 ~= y1 do
+            for i = 0, thickness - 1 do
+                if majorAxis then
+                    setPixel(x0, y0 + i)
+                else
+                    setPixel(x0 + i, y0)
+                end
+            end
+
+            local err2 = 2 * err
+            if err2 > -dy then
+                err = err - dy
+                x0 = x0 + sx
+            end
+            if err2 < dx then
+                err = err + dx
+                y0 = y0 + sy
+            end
+
+            if i % 1024 == 0 then
+                --event.push("paint")
+                --event.pull("paint")
+                --timer.sleep(0)
+            end
+        end
+    end
+    drawLineBresenham()
+end
+
+local function drawUI()
+    term.setBackground(0)
+    term.clear()
+    for y = 1, 16 do
+        term.setPos(tw - 1, y)
+        term.setBackground(0)
+        term.setForeground(colors[y])
+        if selectedColor == y then
+            term.setBackground(colors[y])
+            term.write("  ")
+        else
+            term.write("##")
+        end
+    end
+    term.setPos(tw - 1, 17)
+
+    if selectedColor == 0 then
+        term.setBackground(colors.white)
+        term.setForeground(0)
+    else
+        term.setBackground(0)
+        term.setForeground(colors.white)
+    end
+    term.write("XX")
+
+    term.setPos(tw - 1, 18)
+    term.setBackground(colors.black)
+    term.setForeground(colors.white)
+    term.write(thickness)
+
+    gpu.drawLine(canvasW + 1, 0, canvasW, canvasH, colors.gray, 2)
+
+    local b<close> = gpu.bufferFrom(canvas, canvasW, canvasH)
+    gpu.drawBuffer(b, 0, 0, {
+        source = {
+            0, 0, canvasW, canvasH
+        }
+    })
+end
+
+local function contains(arr, val)
+    for i, v in ipairs(arr) do
+        if v == val then
+            return true
+        end
+    end
+    return false
+end
+
+local oldX, oldY
+while true do
+    drawUI()
+
+    local ev, b, x, y = event.pull("mouse_down", "mouse_up", "mouse_move", "mouse_scroll")
+    local tx, ty = term.fromRealPos(x, y)
+    if ev == "mouse_up" then
+        if x >= canvasW then
+            if ty <= 16 then
+                selectedColor = ty
+            elseif ty == 17 then
+                selectedColor = 0
+            end
+        end
+        oldX, oldY = nil, nil
+    elseif ev == "mouse_down" or (ev == "mouse_move" and contains(b, 1)) then
+        if x < canvasW and y < canvasH then
+            --canvas[x + y * canvasW] = colors[selectedColor] or 0
+            --drawCircle(canvas, x, y, thickness - 2, colors[selectedColor])
+
+            drawLine(canvas, x, y, oldX or x, oldY or y, colors[selectedColor] or 0, thickness)
+            --gpu.drawLine(x, y, oldX or x, oldY or y, colors[selectedColor] or 0)
+            --canvas = gpu.getBuffer()
+
+            oldX, oldY = x, y
+        end
+    elseif ev == "mouse_scroll" then
+        local x, y, b = b, x, y
+        local tx, ty = term.fromRealPos(x, y)
+        if x >= canvasW and ty == 18 then
+            thickness = math.min(99, math.max(0, thickness - b))
+        end
+    end
+end

Capy64/Assets/Lua/CapyOS/sys/bin/hello.lua

@@ -0,0 +1,23 @@
+local timer = require("timer")
+local colors = require("colors")
+local term = require("term")
+
+local function slowPrint(text, delay)
+    for i = 1, #text do
+        local ch = text:sub(i, i)
+        io.write(ch)
+        timer.sleep(delay)
+    end
+    print()
+end
+
+local args = {...}
+local text = "Hello, World!"
+if #args > 0 then
+    text = table.concat(args, " ")
+end
+
+local color = colors[math.random(1, #colors)]
+
+term.setForeground(color)
+slowPrint(text, 0.05)

Capy64/Assets/Lua/CapyOS/sys/bin/help.lua

@@ -0,0 +1,11 @@
+local fs = require("fs")
+local helpPath = "/sys/share/help"
+
+local topicName = arg[1] or "index"
+
+if not fs.exists(fs.combine(helpPath, topicName)) then
+	print(string.format("Topic \"%s\" not found.", topicName))
+	return false
+end
+
+shell.run("/sys/bin/less.lua", fs.combine(helpPath, topicName))

Capy64/Assets/Lua/CapyOS/sys/bin/less.lua

@@ -0,0 +1,78 @@
+local term = require("term")
+local keys = require("keys")
+local event = require("event")
+local fs = require("fs")
+local timer = require("timer")
+local colors = require("colors")
+
+local filename = shell.resolve(arg[1])
+
+local f<close> = fs.open(filename, "r")
+local lines = {}
+local lineMax = 0
+for line in f:lines() do
+    table.insert(lines, line)
+    lineMax = math.max(lineMax, #line)
+end
+f:close()
+
+
+local width, height = term.getSize()
+height = height - 1
+local posx, posy = 0, 0
+
+local function redraw()
+    term.clear()
+    term.setForeground(colors.white)
+    for i = 1, height do
+        if i + posy > #lines then
+            break
+        end
+        term.setPos(-posx + 1, i)
+        term.write(lines[i + posy])
+    end
+
+    term.setForeground(colors.yellow)
+    term.setPos(1, height + 1)
+    term.write("Use arrow keys to move or press Q to exit.")
+end
+
+while true do
+    redraw()
+
+    local _, key = event.pull("key_down")
+
+    if key == keys.enter or key == keys.down then
+        posy = posy + 1
+    elseif key == keys.up then
+        posy = posy - 1
+    elseif key == keys.right then
+        posx = posx + 1
+    elseif key == keys.left then
+        posx = posx - 1
+    elseif key == keys.q or key == keys.escape then
+        -- Clear event queue
+        timer.sleep(0)
+        term.clear()
+        term.setPos(1, 1)
+        break
+    end
+
+    
+
+    if posy > #lines - height then
+        posy = #lines - height
+    end
+
+    if posy < 0 then
+        posy = 0
+    end
+
+    if posx + width > lineMax + 1 then
+        posx = lineMax - width + 1
+    end
+
+    if posx < 0 then
+        posx = 0
+    end
+end

Capy64/Assets/Lua/CapyOS/sys/bin/ls.lua

@@ -0,0 +1,88 @@
+local fs = require("fs")
+local term = require("term")
+local colors = require("colors")
+local argparser = require("argparser")
+
+local theme = {
+    directory = colors.lightBlue,
+    file = colors.white,
+    lua = colors.yellow,
+}
+
+local function humanizeBytes(n)
+    local prefixes = {
+        [0] = "",
+        "k",
+        "M",
+        "G",
+        "T",
+    }
+    local block = 1024
+    local prefixIndex = 0
+
+    while n >= block do
+        n = n / 1024
+        prefixIndex = prefixIndex + 1
+    end
+
+    return string.format("%.0f%s", n, prefixes[prefixIndex])
+end
+
+local args, options = argparser.parse(...)
+
+if options.h or options.help then
+    print("Usage: ls [option...] [path]")
+    print("List files (current directory by default)")
+    print("Options:")
+    print(" -a: Include hidden files")
+    print(" -l: Use long listing format")
+    return
+end
+local path = shell.getDir()
+
+if args[1] then
+    path = shell.resolve(args[1])
+end
+
+if not fs.isDir(path) then
+    error("No such directory: " .. path, 0)
+    return false
+end
+
+local entries = fs.list(path)
+
+if options.l then
+    print(string.format("total %d", #entries))
+end
+local printed = 0
+for i, entry in ipairs(entries) do
+    if entry:sub(1, 1) ~= "." or options.a then
+        printed = printed + 1
+        local attributes = fs.attributes(fs.combine(path, entry))
+        local size = humanizeBytes(attributes.size)
+        local date = os.date("%x %H:%m", attributes.modified // 1000)
+
+        local entryType
+        if attributes.isDirectory then
+            entryType = "directory"
+        else
+            entryType = "file"
+            if string.match(entry, "%.lua$") then
+                entryType = "lua"
+            end
+        end
+
+        if options.l then
+            term.setForeground(colors.white)
+            term.write(string.format("%s %5s %s ", attributes.isDirectory and "d" or "-", size, date))
+        end
+        term.setForeground(theme[entryType])
+        io.write(entry)
+        
+        io.write(options.l and "\n" or "\t")
+    end
+end
+
+if not options.l and printed > 0 then
+    print()
+end

Capy64/Assets/Lua/CapyOS/sys/bin/lua.lua

@@ -0,0 +1,98 @@
+local term = require("term")
+local io = require("io")
+local colors = require("colors")
+local argparser = require("argparser")
+local tableutils = require("tableutils")
+
+local args, options = argparser.parse(...)
+
+local function evaluate(str, env, chunkname)
+    chunkname = chunkname or "=lua"
+    local nForcePrint = 0
+    local func, e = load(str, chunkname, "t", env)
+    local func2 = load("return " .. str, chunkname, "t", env)
+    if not func then
+        if func2 then
+            func = func2
+            e = nil
+            nForcePrint = 1
+        end
+    else
+        if func2 then
+            func = func2
+        end
+    end
+
+    if func then
+        local tResults = table.pack(pcall(func))
+        if tResults[1] then
+            local n = 1
+            while n < tResults.n or n <= nForcePrint do
+                local value = tResults[n + 1]
+                print(tableutils.pretty(value))
+                n = n + 1
+            end
+        else
+            io.stderr.print(tResults[2])
+            return false
+        end
+    else
+        io.stderr.print(e)
+        return false
+    end
+    return true
+end
+
+local function createEnvironment()
+    return setmetatable({}, { __index = _ENV })
+end
+
+local function loadPackages(env)
+    for k, v in pairs(package.loaded) do
+        env[k] = v
+    end
+end
+
+if options.e then
+    local env = createEnvironment()
+    loadPackages(env)
+    return evaluate(table.concat(args, " "), env)
+end
+
+if #args > 0 then
+    print("This is an interactive Lua prompt.")
+    print("To run a lua program, just type its name.")
+    return
+end
+
+--local pretty = require "cc.pretty"
+
+local bRunning = true
+local tCommandHistory = {}
+
+
+local tEnv = createEnvironment()
+tEnv.exit = setmetatable({}, {
+    __tostring = function() return "Call exit() to exit." end,
+    __call = function() bRunning = false end,
+})
+loadPackages(tEnv)
+
+term.setForeground(colors.yellow)
+print(_VERSION .. " interactive prompt")
+print("Call exit() to exit.")
+term.setForeground(colors.white)
+
+while bRunning do
+    term.setForeground(colors.yellow)
+    io.write("> ")
+    term.setForeground(colors.white)
+
+    local s = io.read(nil, tCommandHistory)
+    if s:match("%S") and tCommandHistory[#tCommandHistory] ~= s then
+        table.insert(tCommandHistory, s)
+    end
+
+    evaluate(s, tEnv)
+
+end

Capy64/Assets/Lua/CapyOS/sys/bin/mkdir.lua

@@ -0,0 +1,14 @@
+local fs = require("fs")
+local args = { ... }
+
+if #args == 0 then
+    print("Usage: mkdir <directory>")
+    return
+end
+
+local dir = shell.resolve(args[1])
+if fs.exists(dir) then
+    error("Path already exists", 0)
+end
+
+fs.makeDir(dir)

Capy64/Assets/Lua/CapyOS/sys/bin/motd.lua

@@ -0,0 +1,20 @@
+local fs = require("fs")
+
+local date = os.date("*t")
+
+if date.month == 4 and date.day == 28 then
+    print("Ed Balls")
+    return
+end
+
+local motdList = {}
+
+local f<close> = fs.open("/sys/share/motd.txt", "r")
+for line in f:lines() do
+    table.insert(motdList, line)
+end
+f:close()
+
+local motdIndex = math.random(1, #motdList)
+
+print(motdList[motdIndex])

Capy64/Assets/Lua/CapyOS/sys/bin/mv.lua

@@ -0,0 +1,16 @@
+local fs = require("fs")
+local argparser = require("argparser")
+
+local args, options = argparser.parse(...)
+
+if not args[1] or not args[2] or options.h or options.help then
+    print("Usage: mv [option...] <source> <target>")
+    print("Options:")
+    print(" -h --help: Display help")
+    return
+end
+
+local source = shell.resolve(args[1])
+local destination = shell.resolve(args[2])
+
+fs.move(source, destination)

Capy64/Assets/Lua/CapyOS/sys/bin/programs.lua

@@ -0,0 +1,10 @@
+local fs = require("fs")
+local programs = fs.list("/sys/bin", function(name, attr)
+    return not attr.isDirectory
+end)
+
+for i, v in ipairs(programs) do
+    programs[i] = string.gsub(v, "%.lua$", "")
+end
+
+print(table.concat(programs, " "))

Capy64/Assets/Lua/CapyOS/sys/bin/pwd.lua

@@ -0,0 +1 @@
+print(shell.getDir())

Capy64/Assets/Lua/CapyOS/sys/bin/rm.lua

@@ -0,0 +1,16 @@
+local fs = require("fs")
+local argparser = require("argparser")
+
+local args, options = argparser.parse(...)
+
+if not args[1] or options.h or options.help then
+    print("Usage: rm [option...] <path>")
+    print("Options:")
+    print(" -r --recursive: Delete non-empty directories")
+    print(" -h --help: Display help")
+    return
+end
+
+local file = shell.resolve(args[1])
+
+fs.delete(file, options.recursive or options.r)

Capy64/Assets/Lua/CapyOS/sys/bin/shell.lua

@@ -0,0 +1,175 @@
+local term = require("term")
+local colors = require("colors")
+local fs = require("fs")
+local machine = require("machine")
+local argparser = require("argparser")
+local scheduler = require("scheduler")
+local createPackageEnvironment = require("shell.package")
+
+local useScheduler = false
+local exit = false
+local parentShell = shell
+local isStartupShell = parentShell == nil
+local shell = {}
+
+shell.path = parentShell and parentShell.path or "./?;./?.lua;/bin/?.lua;/sys/bin/?.lua"
+shell.homePath = parentShell and parentShell.home or "/home"
+shell.aliases = parentShell and parentShell.aliases or {}
+
+local currentDir = parentShell and parentShell.getDir() or shell.homePath
+
+local function buildEnvironment(command, filepath, args, argf)
+    local arg = { table.unpack(args, 2) }
+    arg[0] = command
+    arg.string = argf
+
+    local envPackage = createPackageEnvironment(filepath)
+    envPackage.loaded.scheduler = scheduler
+
+    return setmetatable({
+        shell = shell,
+        arg = arg,
+        scheduler = scheduler,
+    }, { __index = envPackage.loaded._G })
+end
+
+function shell.getDir()
+    return currentDir
+end
+
+function shell.setDir(path)
+    currentDir = path
+end
+
+function shell.resolve(path)
+    if path:sub(1, 1) == "/" then
+        return fs.combine("", path)
+    end
+
+    if path:sub(1, 1) == "~" then
+        return fs.combine(shell.homePath, path)
+    end
+
+    return fs.combine(currentDir, path)
+end
+
+function shell.resolveProgram(path)
+    if path:sub(1, 1) == "/" then
+        return shell.resolve(path)
+    end
+
+    for seg in shell.path:gmatch("[^;]+") do
+        local resolved = shell.resolve(seg:gsub("%?", path))
+        if fs.exists(resolved) and not fs.isDir(resolved) then
+            return resolved
+        end
+    end
+end
+
+function shell.run(...)
+    local args = argparser.tokenize(...)
+    local argf = table.concat({...}, " ")
+    local command = args[1]
+
+    argf = argf:sub(#command + 2)
+
+    local path = shell.resolveProgram(command)
+
+    if not path then
+        if shell.aliases[command] then
+            return shell.run(shell.aliases[command], select(2, table.unpack(args)))
+        else
+            io.stderr.print("Command not found: " .. command)
+            return false
+        end
+    end
+
+    local env = buildEnvironment(command, path, args, argf)
+
+    local func, err = loadfile(path, "t", env)
+
+    if not func then
+        io.stderr.print(err)
+        return false
+    end
+
+    local ok, err
+    local function run()
+        ok, err = pcall(func, table.unpack(args, 2))
+    end
+
+    if useScheduler then
+        local programTask, yielded = scheduler.spawn(run)
+
+        if yielded then
+            coroutine.yield("scheduler_task_end")
+        end
+    else
+        run()
+    end
+
+    if not ok then
+        io.stderr.print(err)
+        return false
+    end
+
+    return true
+end
+
+function shell.exit()
+    exit = true
+end
+
+if not fs.exists(shell.homePath) then
+    fs.makeDir(shell.homePath)
+end
+
+term.setForeground(colors.white)
+term.setBackground(colors.black)
+
+if isStartupShell then
+    if fs.exists(fs.combine(shell.homePath, ".shrc")) then
+        local f <close> = fs.open(fs.combine(shell.homePath, ".shrc"), "r")
+        for line in f:lines() do
+            if line:match("%S") and not line:match("^%s-#") then
+                shell.run(line)
+            end
+        end
+        f:close()
+    end
+end
+
+local history = {}
+local lastExecSuccess = true
+while not exit do
+    machine.setRPC(os.version(), "On shell")
+
+    term.setBackground(colors.black)
+    term.setForeground(colors.white)
+    io.write(":")
+    term.setForeground(colors.lightBlue)
+    if currentDir == shell.homePath then
+        io.write("~")
+    else
+        io.write(currentDir)
+    end
+
+    if lastExecSuccess then
+        term.setForeground(colors.yellow)
+    else
+        term.setForeground(colors.red)
+    end
+    io.write("$ ")
+
+    term.setForeground(colors.white)
+    local line = io.read(nil, history)
+
+    if line:match("%S") and history[#history] ~= line then
+        table.insert(history, line)
+    end
+
+    if line:match("%S") then
+        machine.setRPC(os.version(), "Running: " .. line)
+        lastExecSuccess = shell.run(line)
+    end
+end

Capy64/Assets/Lua/CapyOS/sys/bin/shutdown.lua

@@ -0,0 +1,33 @@
+local machine = require("machine")
+local scheduler = require("scheduler")
+local argparser = require("argparser")
+
+local args, options = argparser.parse(...)
+
+if options.h or options.help then
+    print("Usage: shutdown [option...]")
+    print("Shutdown or restart Capy64.")
+    print("Options:")
+    print(" -s --shutdown: Shutdown and exit Capy64. (default)")
+    print(" -r --reboot: Restart Capy64.")
+    print(" -t --time: Time to wait in seconds. (\"now\" is 0 seconds, default)")
+    return
+end
+
+local time = 0
+if options.t or options.time then
+    time = options.t or options.time
+end
+if time == "now" then
+    time = 0
+else
+    time = tonumber(time)
+    if not time then
+        error("Invalid time option: " .. (options.t or options.time), 0)
+    end
+end
+
+scheduler.ipc(1, "power", {
+    reboot = options.r or options.reboot,
+    time = time,
+})

Capy64/Assets/Lua/CapyOS/sys/bin/version.lua

@@ -0,0 +1,2 @@
+local machine = require("machine")
+print(string.format("%s @ %s - %s", os.version(), machine.version(), _VERSION))

Capy64/Assets/Lua/CapyOS/sys/bin/wget.lua

@@ -0,0 +1,36 @@
+local http = require("http")
+local fs = require("fs")
+
+local args = { ... }
+
+if not http then
+    error("HTTP is not enabled", 0)
+end
+
+if #args == 0 then
+    print("Usage: wget <url> [outputPath]")
+    return false
+end
+
+local outputName = args[2] or fs.getName(args[1])
+local outputPath = shell.resolve(outputName)
+
+if not http.checkURL(args[1]) then
+    error("Invalid URL", 0)
+end
+
+print("Connecting...")
+
+local response, err = http.get(args[1], nil, {
+    binary = true,
+})
+if not response then
+    error(err, 0)
+end
+
+local file <close> = fs.open(outputPath, "wb")
+file:write(response.content:read("a"))
+file:close()
+response.content:close()
+
+print("Downloaded to " .. outputPath)

Capy64/Assets/Lua/CapyOS/sys/boot/autorun/00_package.lua

@@ -0,0 +1,3 @@
+package.path = "/lib/?.lua;/lib/?/init.lua;/sys/lib/?.lua;/sys/lib/?/init.lua;" .. package.path
+
+_G.io = require("io")

Capy64/Assets/Lua/CapyOS/sys/boot/autorun/01_stdio.lua

@@ -0,0 +1,15 @@
+function _G.print(...)
+    local args = { ... }
+    local size = #args
+    local lines = 0
+    for n, v in ipairs(args) do
+        local s = tostring(v)
+        if n < size then
+            s = s .. "\t"
+        end
+        lines = lines + io.write(s)
+    end
+    lines = lines + io.write("\n")
+
+    return lines
+end

Capy64/Assets/Lua/CapyOS/sys/boot/autorun/02_fs.lua

@@ -0,0 +1,28 @@
+local fs = require("fs")
+local expect = require("expect").expect
+
+local fsList = fs.list
+
+function fs.list(path, filter)
+    expect(1, path, "string")
+    expect(2, filter, "nil", "function")
+
+    if not fs.isDir(path) then
+        error("directory not found", 2)
+    end
+
+    local list = fsList(path)
+    if not filter then
+        return list
+    end
+
+    local filteredList = {}
+    for i = 1, #list do
+        local attributes = fs.attributes(fs.combine(path, list[i]))
+        if filter(list[i], attributes) then
+            table.insert(filteredList, list[i])
+        end
+    end
+
+    return filteredList
+end

Capy64/Assets/Lua/CapyOS/sys/boot/autorun/02_http.lua

@@ -0,0 +1,77 @@
+local http = require("http")
+local event = require("event")
+local expect = require("expect").expect
+
+
+function http.request(url, body, headers, options)
+    expect(1, url, "string")
+    expect(2, body, "string", "nil")
+    expect(3, headers, "table", "nil")
+    expect(4, options, "table", "nil")
+
+    if not http.checkURL(url) then
+        return nil, "Invalid URL"
+    end
+
+    local task<close> = http.requestAsync(url, body, headers, options)
+    return task:await()
+end
+
+function http.get(url, headers, options)
+    expect(1, url, "string")
+    expect(2, headers, "table", "nil")
+    expect(3, options, "table", "nil")
+
+    return http.request(url, nil, headers, options)
+end
+
+function http.post(url, body, headers, options)
+    expect(1, url, "string")
+    expect(2, body, "string", "nil")
+    expect(3, headers, "table", "nil")
+    expect(4, options, "table", "nil")
+
+    return http.request(url, body, headers, options)
+end
+
+local WebSocketHandle
+local function buildWebsocketHandle(handle)
+    if not handle then
+        return nil
+    end
+    if not WebSocketHandle then
+        WebSocketHandle = getmetatable(handle) or { __index = {} }
+        function WebSocketHandle.__index:close()
+            self:closeAsync()
+            local _, id
+            repeat
+                _, id = event.pull("websocket_close")
+            until id == self:getRequestID()
+        end
+
+        function WebSocketHandle.__index:receive()
+            local _, id, par
+            repeat
+                _, id, par = event.pull("websocket_message")
+            until id == self:getRequestID()
+
+            return par
+        end
+    end
+
+    return handle
+end
+
+function http.websocket(url, headers)
+    expect(1, url, "string")
+    expect(2, headers, "table", "nil")
+
+    if not http.checkURL(url) then
+        return nil, "Invalid URL"
+    end
+
+    local task<close> = http.websocketAsync(url, headers)
+    local client, err = task:await()
+
+    return buildWebsocketHandle(client), err
+end

Capy64/Assets/Lua/CapyOS/sys/boot/autorun/02_timer.lua

@@ -0,0 +1,13 @@
+local timer = require("timer")
+local event = require("event")
+local expect = require("expect").expect
+local range = require("expect").range
+
+function timer.sleep(n)
+    expect(1, n, "number")
+
+    local timerId = timer.start(n)
+    repeat
+        local _, par = event.pull("timer")
+    until par == timerId
+end

Capy64/Assets/Lua/CapyOS/sys/boot/autorun/50_os_manager.lua

@@ -0,0 +1,47 @@
+local machine = require("machine")
+local scheduler = require("scheduler")
+
+local term = require("term")
+local colors = require("colors")
+term.setForeground(0x59c9ff)
+term.setBackground(colors.black)
+term.clear()
+term.setPos(1, 1)
+
+term.write(os.version())
+term.setPos(1, 2)
+
+local function spawnShell()
+    return scheduler.spawn(loadfile("/sys/bin/shell.lua"))
+end
+
+local function main()
+    local shellTask = spawnShell()
+    while true do
+        local ev = {coroutine.yield()}
+        if ev[1] == "ipc_message" then
+            local sender = ev[2]
+            local call = ev[3]
+            if call == "power" then
+                local options = ev[4]
+                --todo: handle time and cancels
+                if options.reboot then
+                    machine.reboot()
+                else
+                    machine.shutdown()
+                end
+            end
+        elseif ev[1] == "scheduler_task_end" then
+            if ev[2].pid == shellTask.pid then
+                if not ev[3] then
+                    io.stderr.print(ev[4])
+                end
+                shellTask = spawnShell()
+            end
+        end
+    end
+end
+
+scheduler.spawn(main)
+
+scheduler.init()

Capy64/Assets/Lua/CapyOS/sys/boot/autorun/999_shutdown.lua

@@ -0,0 +1 @@
+require("machine").shutdown()

Capy64/Assets/Lua/CapyOS/sys/lib/argparser.lua

@@ -0,0 +1,91 @@
+local argparser = {}
+
+function argparser.tokenize(...)
+    local input = table.concat(table.pack(...), " ")
+    local tokens = {}
+
+    -- surely there must be a better way
+    local quoted = false
+    local escaped = false
+    local current = ""
+    for i = 1, #input do
+        local char = input:sub(i, i)
+        if escaped then
+            escaped = false
+            current = current .. char
+        else
+            if char == "\\" then
+                escaped = true
+            elseif char == "\"" then
+                if quoted then
+                    -- close quote
+                    table.insert(tokens, current)
+                    current = ""
+                end
+                quoted = not quoted
+            elseif char == " " and not quoted then
+                if #current > 0 then
+                    table.insert(tokens, current)
+                end
+                current = ""
+            else
+                current = current .. char
+            end
+        end
+    end
+
+    if current ~= "" then
+        table.insert(tokens, current)
+    end
+
+    return tokens
+end
+
+function argparser.parse(...)
+    local tokens = { ... }
+    local args = {}
+    local options = {}
+    local ignoreOptions = false
+
+    for i = 1, #tokens do
+        local token = tokens[i]
+        if not ignoreOptions then
+            if token == "--" then
+                ignoreOptions = true
+            elseif token:sub(1, 2) == "--" then
+                local opt, value = token:match("%-%-(.+)=(.+)")
+                if not opt then
+                    opt = token:sub(3)
+                    if opt:sub(-1) == "=" then
+                        -- next token is value
+                        value = tokens[i + 1]
+                        opt = opt:sub(1, -2)
+                        options[opt] = value
+                        i = i + 1
+                    else
+                        options[opt] = true
+                    end
+                else
+                    options[opt] = value
+                end
+            elseif token:sub(1, 1) == "-" then
+                local opts = token:sub(2)
+                for j = 1, #opts do
+                    options[opts:sub(j, j)] = true
+                end
+            else
+                if #token > 0 then
+                    table.insert(args, token)
+                end
+            end
+        else
+            if #token > 0 then
+                table.insert(args, token)
+            end
+        end
+    end
+
+    return args, options
+end
+
+return argparser

Capy64/Assets/Lua/CapyOS/sys/lib/colors.lua

@@ -0,0 +1,94 @@
+local expect = require("expect")
+
+local palette = {
+    {
+        "white",
+        0xf0f0f0
+    },
+    {
+        "orange",
+        0xf2b233
+    },
+    {
+        "magenta",
+        0xe57fd8
+    },
+    {
+        "lightBlue",
+        0x99b2f2
+    },
+    {
+        "yellow",
+        0xdede6c
+    },
+    {
+        "lime",
+        0x7fcc19
+    },
+    {
+        "pink",
+        0xf2b2cc
+    },
+    {
+        "gray",
+        0x4c4c4c
+    },
+    {
+        "lightGray",
+        0x999999
+    },
+    {
+        "cyan",
+        0x4c99b2
+    },
+    {
+        "purple",
+        0xb266e5
+    },
+    {
+        "blue",
+        0x3366cc
+    },
+    {
+        "brown",
+        0x7f664c
+    },
+    {
+        "green",
+        0x57a64e
+    },
+    {
+        "red",
+        0xcc4c4c
+    },
+    {
+        "black",
+        0x111111
+    }
+}
+
+local colors = {}
+for k, v in ipairs(palette) do
+    colors[v[1]] = v[2]
+    colors[k] = v[2]
+end
+
+function colors.packRGB(r, g, b)
+    expect(1, r, "number")
+    expect(2, g, "number")
+    expect(3, b, "number")
+
+    return (r << 16) +
+        (g << 8) +
+        b
+end
+
+function colors.unpackRGB(rgb)
+    expect(1, rgb, "number")
+
+    return (rgb >> 16) & 0xff,
+        (rgb >> 8) & 0xff,
+        rgb & 0xff
+end
+
+return colors;

Capy64/Assets/Lua/CapyOS/sys/lib/expect.lua

@@ -0,0 +1,52 @@
+-- Credits: https://github.com/Ocawesome101/recrafted
+
+-- cc.expect
+
+local _expect = {}
+
+local function checkType(index, valueType, value, ...)
+    local expected = table.pack(...)
+    local isType = false
+
+    for i = 1, expected.n, 1 do
+        if type(value) == expected[i] then
+            isType = true
+            break
+        end
+    end
+
+    if not isType then
+        error(string.format("bad %s %s (%s expected, got %s)", valueType,
+            index, table.concat(expected, " or "), type(value)), 3)
+    end
+
+    return value
+end
+
+function _expect.expect(index, value, ...)
+    return checkType(("#%d"):format(index), "argument", value, ...)
+end
+
+function _expect.field(tbl, index, ...)
+    _expect.expect(1, tbl, "table")
+    _expect.expect(2, index, "string")
+    return checkType(("%q"):format(index), "field", tbl[index], ...)
+end
+
+function _expect.range(num, min, max)
+    _expect.expect(1, num, "number")
+    _expect.expect(2, min, "number", "nil")
+    _expect.expect(3, max, "number", "nil")
+    min = min or -math.huge
+    max = max or math.huge
+    if num < min or num > max then
+        error(("number outside of range (expected %d to be within %d and %d")
+            :format(num, min, max), 2)
+    end
+end
+
+setmetatable(_expect, { __call = function(_, ...)
+    return _expect.expect(...)
+end })
+
+return _expect

Capy64/Assets/Lua/CapyOS/sys/lib/io.lua

@@ -0,0 +1,616 @@
+local expect = require("expect").expect
+local event = require("event")
+local term = require("term")
+local keys = require("keys")
+local machine = require("machine")
+
+local io = {}
+
+function io.write(sText)
+    sText = tostring(sText)
+
+    local w, h = term.getSize()
+    local x, y = term.getPos()
+
+    local nLinesPrinted = 0
+    local function newLine()
+        if y + 1 <= h then
+            term.setPos(1, y + 1)
+        else
+            term.setPos(1, h)
+            term.scroll(1)
+        end
+        x, y = term.getPos()
+        nLinesPrinted = nLinesPrinted + 1
+    end
+
+    -- Print the line with proper word wrapping
+    sText = tostring(sText)
+    while #sText > 0 do
+        local whitespace = string.match(sText, "^[ \t]+")
+        if whitespace then
+            -- Print whitespace
+            term.write(whitespace)
+            x, y = term.getPos()
+            sText = string.sub(sText, #whitespace + 1)
+        end
+
+        local newline = string.match(sText, "^\n")
+        if newline then
+            -- Print newlines
+            newLine()
+            sText = string.sub(sText, 2)
+        end
+
+        local text = string.match(sText, "^[^ \t\n]+")
+        if text then
+            sText = string.sub(sText, #text + 1)
+            if #text > w then
+                -- Print a multiline word
+                while #text > 0 do
+                    if x > w then
+                        newLine()
+                    end
+                    term.write(text)
+                    text = string.sub(text, w - x + 2)
+                    x, y = term.getPos()
+                end
+            else
+                -- Print a word normally
+                if x + #text - 1 > w then
+                    newLine()
+                end
+                term.write(text)
+                x, y = term.getPos()
+            end
+        end
+    end
+
+    return nLinesPrinted
+end
+
+function io.read(_sReplaceChar, _tHistory, _fnComplete, _sDefault)
+    expect(1, _sReplaceChar, "string", "nil")
+    expect(2, _tHistory, "table", "nil")
+    expect(3, _fnComplete, "function", "nil")
+    expect(4, _sDefault, "string", "nil")
+
+    term.setBlink(true)
+
+    local sLine
+    if type(_sDefault) == "string" then
+        sLine = _sDefault
+    else
+        sLine = ""
+    end
+    local nHistoryPos
+    local nPos, nScroll = #sLine, 0
+    if _sReplaceChar then
+        _sReplaceChar = string.sub(_sReplaceChar, 1, 1)
+    end
+
+    local tCompletions
+    local nCompletion
+    local function recomplete()
+        if _fnComplete and nPos == #sLine then
+            tCompletions = _fnComplete(sLine)
+            if tCompletions and #tCompletions > 0 then
+                nCompletion = 1
+            else
+                nCompletion = nil
+            end
+        else
+            tCompletions = nil
+            nCompletion = nil
+        end
+    end
+
+    local function uncomplete()
+        tCompletions = nil
+        nCompletion = nil
+    end
+
+    local w = term.getSize()
+    local sx = term.getPos()
+
+    local function redraw(_bClear)
+        local cursor_pos = nPos - nScroll
+        if sx + cursor_pos >= w then
+            -- We've moved beyond the RHS, ensure we're on the edge.
+            nScroll = sx + nPos - w
+        elseif cursor_pos < 0 then
+            -- We've moved beyond the LHS, ensure we're on the edge.
+            nScroll = nPos
+        end
+
+        local _, cy = term.getPos()
+        term.setPos(sx, cy)
+        local sReplace = _bClear and " " or _sReplaceChar
+        if sReplace then
+            term.write(string.rep(sReplace, math.max(#sLine - nScroll, 0)))
+        else
+            term.write(string.sub(sLine, nScroll + 1))
+        end
+
+        if nCompletion then
+            local sCompletion = tCompletions[nCompletion]
+            local oldText, oldBg
+            if not _bClear then
+                oldText = term.getTextColor()
+                oldBg = term.getBackgroundColor()
+                term.setTextColor(colors.white)
+                term.setBackgroundColor(colors.gray)
+            end
+            if sReplace then
+                term.write(string.rep(sReplace, #sCompletion))
+            else
+                term.write(sCompletion)
+            end
+            if not _bClear then
+                term.setTextColor(oldText)
+                term.setBackgroundColor(oldBg)
+            end
+        end
+
+        term.setPos(sx + nPos - nScroll, cy)
+    end
+
+    local function clear()
+        redraw(true)
+    end
+
+    recomplete()
+    redraw()
+
+    local function acceptCompletion()
+        if nCompletion then
+            -- Clear
+            clear()
+
+            -- Find the common prefix of all the other suggestions which start with the same letter as the current one
+            local sCompletion = tCompletions[nCompletion]
+            sLine = sLine .. sCompletion
+            nPos = #sLine
+
+            -- Redraw
+            recomplete()
+            redraw()
+        end
+    end
+    while true do
+        local sEvent, param, param1, param2 = event.pull()
+        if sEvent == "char" then
+            -- Typed key
+            clear()
+            sLine = string.sub(sLine, 1, nPos) .. param .. string.sub(sLine, nPos + 1)
+            nPos = nPos + 1
+            recomplete()
+            redraw()
+
+        elseif sEvent == "paste" then
+            -- Pasted text
+            clear()
+            sLine = string.sub(sLine, 1, nPos) .. param .. string.sub(sLine, nPos + 1)
+            nPos = nPos + #param
+            recomplete()
+            redraw()
+
+        elseif sEvent == "key_down" then
+            if param == keys.enter or param == keys.numPadEnter then
+                -- Enter/Numpad Enter
+                if nCompletion then
+                    clear()
+                    uncomplete()
+                    redraw()
+                end
+                break
+
+            elseif param == keys.left then
+                -- Left
+                if nPos > 0 then
+                    clear()
+                    nPos = nPos - 1
+                    recomplete()
+                    redraw()
+                end
+
+            elseif param == keys.right then
+                -- Right
+                if nPos < #sLine then
+                    -- Move right
+                    clear()
+                    nPos = nPos + 1
+                    recomplete()
+                    redraw()
+                else
+                    -- Accept autocomplete
+                    acceptCompletion()
+                end
+
+            elseif param == keys.up or param == keys.down then
+                -- Up or down
+                if nCompletion then
+                    -- Cycle completions
+                    clear()
+                    if param == keys.up then
+                        nCompletion = nCompletion - 1
+                        if nCompletion < 1 then
+                            nCompletion = #tCompletions
+                        end
+                    elseif param == keys.down then
+                        nCompletion = nCompletion + 1
+                        if nCompletion > #tCompletions then
+                            nCompletion = 1
+                        end
+                    end
+                    redraw()
+
+                elseif _tHistory then
+                    -- Cycle history
+                    clear()
+                    if param == keys.up then
+                        -- Up
+                        if nHistoryPos == nil then
+                            if #_tHistory > 0 then
+                                nHistoryPos = #_tHistory
+                            end
+                        elseif nHistoryPos > 1 then
+                            nHistoryPos = nHistoryPos - 1
+                        end
+                    else
+                        -- Down
+                        if nHistoryPos == #_tHistory then
+                            nHistoryPos = nil
+                        elseif nHistoryPos ~= nil then
+                            nHistoryPos = nHistoryPos + 1
+                        end
+                    end
+                    if nHistoryPos then
+                        sLine = _tHistory[nHistoryPos]
+                        nPos, nScroll = #sLine, 0
+                    else
+                        sLine = ""
+                        nPos, nScroll = 0, 0
+                    end
+                    uncomplete()
+                    redraw()
+
+                end
+
+            elseif param == keys.back then
+                -- Backspace
+                if nPos > 0 then
+                    clear()
+                    sLine = string.sub(sLine, 1, nPos - 1) .. string.sub(sLine, nPos + 1)
+                    nPos = nPos - 1
+                    if nScroll > 0 then nScroll = nScroll - 1 end
+                    recomplete()
+                    redraw()
+                end
+
+            elseif param == keys.home then
+                -- Home
+                if nPos > 0 then
+                    clear()
+                    nPos = 0
+                    recomplete()
+                    redraw()
+                end
+
+            elseif param == keys.delete then
+                -- Delete
+                if nPos < #sLine then
+                    clear()
+                    sLine = string.sub(sLine, 1, nPos) .. string.sub(sLine, nPos + 2)
+                    recomplete()
+                    redraw()
+                end
+
+            elseif param == keys["end"] then
+                -- End
+                if nPos < #sLine then
+                    clear()
+                    nPos = #sLine
+                    recomplete()
+                    redraw()
+                end
+
+            elseif param == keys.tab then
+                -- Tab (accept autocomplete)
+                acceptCompletion()
+
+            end
+
+        elseif sEvent == "mouse_down" or sEvent == "mouse_drag" and param == 1 then
+            local _, cy = term.getPos()
+            if param1 >= sx and param1 <= w and param2 == cy then
+                -- Ensure we don't scroll beyond the current line
+                nPos = math.min(math.max(nScroll + param1 - sx, 0), #sLine)
+                redraw()
+            end
+
+        elseif sEvent == "term_resize" then
+            -- Terminal resized
+            w = term.getSize()
+            redraw()
+
+        end
+    end
+
+    local _, cy = term.getPos()
+    term.setBlink(false)
+    term.setPos(w + 1, cy)
+    print()
+
+    return sLine
+end
+
+
+--[[function io.write(text)
+    text = tostring(text)
+
+    local lines = 0
+    local w, h = term.getSize()
+
+    local function inc_cy(cy)
+        lines = lines + 1
+
+        if cy > h - 1 then
+            term.scroll(1)
+            return cy
+        else
+            return cy + 1
+        end
+    end
+
+    while #text > 0 do
+        local nl = text:find("\n") or #text
+        local chunk = text:sub(1, nl)
+        text = text:sub(#chunk + 1)
+
+        local has_nl = chunk:sub(-1) == "\n"
+        if has_nl then chunk = chunk:sub(1, -2) end
+
+        local cx, cy = term.getPos()
+        while #chunk > 0 do
+            if cx > w then
+                term.setPos(1, inc_cy(cy))
+                cx, cy = term.getPos()
+            end
+
+            local to_write = chunk:sub(1, w - cx + 1)
+            term.write(to_write)
+
+            chunk = chunk:sub(#to_write + 1)
+            cx, cy = term.getPos()
+        end
+
+        if has_nl then
+            term.setPos(1, inc_cy(cy))
+        end
+    end
+
+    return lines
+end
+
+local empty = {}
+function io.read(replace, history, complete, default)
+    expect(1, replace, "string", "nil")
+    expect(2, history, "table", "nil")
+    expect(3, complete, "function", "nil")
+    expect(4, default, "string", "nil")
+
+    if replace then replace = replace:sub(1, 1) end
+    local hist = history or {}
+    history = {}
+    for i = 1, #hist, 1 do
+        history[i] = hist[i]
+    end
+
+    local buffer = default or ""
+    local prev_buf = buffer
+    history[#history + 1] = buffer
+
+    local hist_pos = #history
+    local cursor_pos = 0
+
+    local stx, sty = term.getPos()
+    local w, h = term.getSize()
+
+    local dirty = false
+    local completions = {}
+    local comp_id = 0
+
+    local function clearCompletion()
+        if completions[comp_id] then
+            io.write((" "):rep(#completions[comp_id]))
+        end
+    end
+
+    local function full_redraw(force)
+        if force or dirty then
+            if complete and buffer ~= prev_buf then
+                completions = complete(buffer) or empty
+                comp_id = math.min(1, #completions)
+            end
+            prev_buf = buffer
+
+            term.setPos(stx, sty)
+            local text = buffer
+            if replace then text = replace:rep(#text) end
+            local ln = io.write(text)
+
+            if completions[comp_id] then
+                local oldfg = term.getForeground()
+                local oldbg = term.getBackground()
+                term.setForeground(colors.white)
+                term.setBackground(colors.gray)
+                ln = ln + write(completions[comp_id])
+                term.setForeground(oldfg)
+                term.setBackground(oldbg)
+            else
+                ln = ln + io.write(" ")
+            end
+
+            if sty + ln > h then
+                sty = sty - (sty + ln - h)
+            end
+        end
+
+        -- set cursor to the appropriate spot
+        local cx, cy = stx, sty
+        cx = cx + #buffer - cursor_pos -- + #(completions[comp_id] or "")
+        while cx > w do
+            cx = cx - w
+            cy = cy + 1
+        end
+        term.setPos(cx, cy)
+    end
+
+    term.setBlink(true)
+
+    while true do
+        full_redraw()
+        -- get input
+        local evt, par1, par2, mods = event.pull()
+
+        if evt == "char" then
+            dirty = true
+            clearCompletion()
+            if cursor_pos == 0 then
+                buffer = buffer .. par1
+            elseif cursor_pos == #buffer then
+                buffer = par1 .. buffer
+            else
+                buffer = buffer:sub(0, -cursor_pos - 1) .. par1 .. buffer:sub(-cursor_pos)
+            end
+        elseif evt == "key_down" then
+            if par1 == keys.back and #buffer > 0 then
+                dirty = true
+                if cursor_pos == 0 then
+                    buffer = buffer:sub(1, -2)
+                    clearCompletion()
+                elseif cursor_pos < #buffer then
+                    buffer = buffer:sub(0, -cursor_pos - 2) .. buffer:sub(-cursor_pos)
+                end
+            elseif par1 == keys.delete and cursor_pos > 0 then
+                dirty = true
+
+                if cursor_pos == #buffer then
+                    buffer = buffer:sub(2)
+                elseif cursor_pos == 1 then
+                    buffer = buffer:sub(1, -2)
+                else
+                    buffer = buffer:sub(0, -cursor_pos - 1) .. buffer:sub(-cursor_pos + 1)
+                end
+                cursor_pos = cursor_pos - 1
+            elseif par1 == keys.up then
+                if #completions > 1 then
+                    dirty = true
+                    clearCompletion()
+                    if comp_id > 1 then
+                        comp_id = comp_id - 1
+                    else
+                        comp_id = #completions
+                    end
+                elseif hist_pos > 1 then
+                    cursor_pos = 0
+
+                    history[hist_pos] = buffer
+                    hist_pos = hist_pos - 1
+
+                    buffer = (" "):rep(#buffer)
+                    full_redraw(true)
+
+                    buffer = history[hist_pos]
+                    dirty = true
+                end
+            elseif par1 == keys.down then
+                if #completions > 1 then
+                    dirty = true
+                    clearCompletion()
+                    if comp_id < #completions then
+                        comp_id = comp_id + 1
+                    else
+                        comp_id = 1
+                    end
+                elseif hist_pos < #history then
+                    cursor_pos = 0
+
+                    history[hist_pos] = buffer
+                    hist_pos = hist_pos + 1
+
+                    buffer = (" "):rep(#buffer)
+                    full_redraw(true)
+
+                    buffer = history[hist_pos]
+                    dirty = true
+                end
+            elseif par1 == keys.left then
+                if cursor_pos < #buffer then
+                    clearCompletion()
+                    cursor_pos = cursor_pos + 1
+                end
+            elseif par1 == keys.right then
+                if cursor_pos > 0 then
+                    cursor_pos = cursor_pos - 1
+                elseif comp_id > 0 then
+                    dirty = true
+                    buffer = buffer .. completions[comp_id]
+                end
+            elseif par1 == keys.tab then
+                if comp_id > 0 then
+                    dirty = true
+                    buffer = buffer .. completions[comp_id]
+                end
+            elseif par1 == keys.home then
+                cursor_pos = #buffer
+            elseif par1 == keys["end"] then
+                cursor_pos = 0
+            elseif par1 == keys.enter then
+                clearCompletion()
+                print()
+                break
+            elseif mods & keys.mods.ctrl ~= 0 then
+                if par1 == keys.v then
+                    dirty = true
+                    clearCompletion()
+                    local text = machine.getClipboard()
+                    if text then
+                        if cursor_pos == 0 then
+                            buffer = buffer .. text
+                        elseif cursor_pos == #buffer then
+                            buffer = text .. buffer
+                        else
+                            buffer = buffer:sub(0, -cursor_pos - 1) .. text ..
+                                buffer:sub(-cursor_pos + (#text - 1))
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+    term.setBlink(false)
+
+    return buffer
+end
+]]
+
+io.stderr = {}
+
+function io.stderr.write(text)
+    local fg = term.getForeground()
+    term.setForeground(0xff0000)
+    io.write(text)
+    term.setForeground(fg)
+end
+
+function io.stderr.print(...)
+    local fg = term.getForeground()
+    term.setForeground(0xff0000)
+    print(...)
+    term.setForeground(fg)
+end
+
+return io

Capy64/Assets/Lua/CapyOS/sys/lib/json.lua

@@ -0,0 +1,388 @@
+--
+-- json.lua
+--
+-- Copyright (c) 2020 rxi
+--
+-- Permission is hereby granted, free of charge, to any person obtaining a copy of
+-- this software and associated documentation files (the "Software"), to deal in
+-- the Software without restriction, including without limitation the rights to
+-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+-- of the Software, and to permit persons to whom the Software is furnished to do
+-- so, subject to the following conditions:
+--
+-- The above copyright notice and this permission notice shall be included in all
+-- copies or substantial portions of the Software.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+-- SOFTWARE.
+--
+
+local json = { _version = "0.1.2" }
+
+-------------------------------------------------------------------------------
+-- Encode
+-------------------------------------------------------------------------------
+
+local encode
+
+local escape_char_map = {
+  [ "\\" ] = "\\",
+  [ "\"" ] = "\"",
+  [ "\b" ] = "b",
+  [ "\f" ] = "f",
+  [ "\n" ] = "n",
+  [ "\r" ] = "r",
+  [ "\t" ] = "t",
+}
+
+local escape_char_map_inv = { [ "/" ] = "/" }
+for k, v in pairs(escape_char_map) do
+  escape_char_map_inv[v] = k
+end
+
+
+local function escape_char(c)
+  return "\\" .. (escape_char_map[c] or string.format("u%04x", c:byte()))
+end
+
+
+local function encode_nil(val)
+  return "null"
+end
+
+
+local function encode_table(val, stack)
+  local res = {}
+  stack = stack or {}
+
+  -- Circular reference?
+  if stack[val] then error("circular reference") end
+
+  stack[val] = true
+
+  if rawget(val, 1) ~= nil or next(val) == nil then
+    -- Treat as array -- check keys are valid and it is not sparse
+    local n = 0
+    for k in pairs(val) do
+      if type(k) ~= "number" then
+        error("invalid table: mixed or invalid key types")
+      end
+      n = n + 1
+    end
+    if n ~= #val then
+      error("invalid table: sparse array")
+    end
+    -- Encode
+    for i, v in ipairs(val) do
+      table.insert(res, encode(v, stack))
+    end
+    stack[val] = nil
+    return "[" .. table.concat(res, ",") .. "]"
+
+  else
+    -- Treat as an object
+    for k, v in pairs(val) do
+      if type(k) ~= "string" then
+        error("invalid table: mixed or invalid key types")
+      end
+      table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
+    end
+    stack[val] = nil
+    return "{" .. table.concat(res, ",") .. "}"
+  end
+end
+
+
+local function encode_string(val)
+  return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
+end
+
+
+local function encode_number(val)
+  -- Check for NaN, -inf and inf
+  if val ~= val or val <= -math.huge or val >= math.huge then
+    error("unexpected number value '" .. tostring(val) .. "'")
+  end
+  return string.format("%.14g", val)
+end
+
+
+local type_func_map = {
+  [ "nil"     ] = encode_nil,
+  [ "table"   ] = encode_table,
+  [ "string"  ] = encode_string,
+  [ "number"  ] = encode_number,
+  [ "boolean" ] = tostring,
+}
+
+
+encode = function(val, stack)
+  local t = type(val)
+  local f = type_func_map[t]
+  if f then
+    return f(val, stack)
+  end
+  error("unexpected type '" .. t .. "'")
+end
+
+
+function json.encode(val)
+  return ( encode(val) )
+end
+
+
+-------------------------------------------------------------------------------
+-- Decode
+-------------------------------------------------------------------------------
+
+local parse
+
+local function create_set(...)
+  local res = {}
+  for i = 1, select("#", ...) do
+    res[ select(i, ...) ] = true
+  end
+  return res
+end
+
+local space_chars   = create_set(" ", "\t", "\r", "\n")
+local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
+local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
+local literals      = create_set("true", "false", "null")
+
+local literal_map = {
+  [ "true"  ] = true,
+  [ "false" ] = false,
+  [ "null"  ] = nil,
+}
+
+
+local function next_char(str, idx, set, negate)
+  for i = idx, #str do
+    if set[str:sub(i, i)] ~= negate then
+      return i
+    end
+  end
+  return #str + 1
+end
+
+
+local function decode_error(str, idx, msg)
+  local line_count = 1
+  local col_count = 1
+  for i = 1, idx - 1 do
+    col_count = col_count + 1
+    if str:sub(i, i) == "\n" then
+      line_count = line_count + 1
+      col_count = 1
+    end
+  end
+  error( string.format("%s at line %d col %d", msg, line_count, col_count) )
+end
+
+
+local function codepoint_to_utf8(n)
+  -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
+  local f = math.floor
+  if n <= 0x7f then
+    return string.char(n)
+  elseif n <= 0x7ff then
+    return string.char(f(n / 64) + 192, n % 64 + 128)
+  elseif n <= 0xffff then
+    return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
+  elseif n <= 0x10ffff then
+    return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
+                       f(n % 4096 / 64) + 128, n % 64 + 128)
+  end
+  error( string.format("invalid unicode codepoint '%x'", n) )
+end
+
+
+local function parse_unicode_escape(s)
+  local n1 = tonumber( s:sub(1, 4),  16 )
+  local n2 = tonumber( s:sub(7, 10), 16 )
+   -- Surrogate pair?
+  if n2 then
+    return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
+  else
+    return codepoint_to_utf8(n1)
+  end
+end
+
+
+local function parse_string(str, i)
+  local res = ""
+  local j = i + 1
+  local k = j
+
+  while j <= #str do
+    local x = str:byte(j)
+
+    if x < 32 then
+      decode_error(str, j, "control character in string")
+
+    elseif x == 92 then -- `\`: Escape
+      res = res .. str:sub(k, j - 1)
+      j = j + 1
+      local c = str:sub(j, j)
+      if c == "u" then
+        local hex = str:match("^[dD][89aAbB]%x%x\\u%x%x%x%x", j + 1)
+                 or str:match("^%x%x%x%x", j + 1)
+                 or decode_error(str, j - 1, "invalid unicode escape in string")
+        res = res .. parse_unicode_escape(hex)
+        j = j + #hex
+      else
+        if not escape_chars[c] then
+          decode_error(str, j - 1, "invalid escape char '" .. c .. "' in string")
+        end
+        res = res .. escape_char_map_inv[c]
+      end
+      k = j + 1
+
+    elseif x == 34 then -- `"`: End of string
+      res = res .. str:sub(k, j - 1)
+      return res, j + 1
+    end
+
+    j = j + 1
+  end
+
+  decode_error(str, i, "expected closing quote for string")
+end
+
+
+local function parse_number(str, i)
+  local x = next_char(str, i, delim_chars)
+  local s = str:sub(i, x - 1)
+  local n = tonumber(s)
+  if not n then
+    decode_error(str, i, "invalid number '" .. s .. "'")
+  end
+  return n, x
+end
+
+
+local function parse_literal(str, i)
+  local x = next_char(str, i, delim_chars)
+  local word = str:sub(i, x - 1)
+  if not literals[word] then
+    decode_error(str, i, "invalid literal '" .. word .. "'")
+  end
+  return literal_map[word], x
+end
+
+
+local function parse_array(str, i)
+  local res = {}
+  local n = 1
+  i = i + 1
+  while 1 do
+    local x
+    i = next_char(str, i, space_chars, true)
+    -- Empty / end of array?
+    if str:sub(i, i) == "]" then
+      i = i + 1
+      break
+    end
+    -- Read token
+    x, i = parse(str, i)
+    res[n] = x
+    n = n + 1
+    -- Next token
+    i = next_char(str, i, space_chars, true)
+    local chr = str:sub(i, i)
+    i = i + 1
+    if chr == "]" then break end
+    if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
+  end
+  return res, i
+end
+
+
+local function parse_object(str, i)
+  local res = {}
+  i = i + 1
+  while 1 do
+    local key, val
+    i = next_char(str, i, space_chars, true)
+    -- Empty / end of object?
+    if str:sub(i, i) == "}" then
+      i = i + 1
+      break
+    end
+    -- Read key
+    if str:sub(i, i) ~= '"' then
+      decode_error(str, i, "expected string for key")
+    end
+    key, i = parse(str, i)
+    -- Read ':' delimiter
+    i = next_char(str, i, space_chars, true)
+    if str:sub(i, i) ~= ":" then
+      decode_error(str, i, "expected ':' after key")
+    end
+    i = next_char(str, i + 1, space_chars, true)
+    -- Read value
+    val, i = parse(str, i)
+    -- Set
+    res[key] = val
+    -- Next token
+    i = next_char(str, i, space_chars, true)
+    local chr = str:sub(i, i)
+    i = i + 1
+    if chr == "}" then break end
+    if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
+  end
+  return res, i
+end
+
+
+local char_func_map = {
+  [ '"' ] = parse_string,
+  [ "0" ] = parse_number,
+  [ "1" ] = parse_number,
+  [ "2" ] = parse_number,
+  [ "3" ] = parse_number,
+  [ "4" ] = parse_number,
+  [ "5" ] = parse_number,
+  [ "6" ] = parse_number,
+  [ "7" ] = parse_number,
+  [ "8" ] = parse_number,
+  [ "9" ] = parse_number,
+  [ "-" ] = parse_number,
+  [ "t" ] = parse_literal,
+  [ "f" ] = parse_literal,
+  [ "n" ] = parse_literal,
+  [ "[" ] = parse_array,
+  [ "{" ] = parse_object,
+}
+
+
+parse = function(str, idx)
+  local chr = str:sub(idx, idx)
+  local f = char_func_map[chr]
+  if f then
+    return f(str, idx)
+  end
+  decode_error(str, idx, "unexpected character '" .. chr .. "'")
+end
+
+
+function json.decode(str)
+  if type(str) ~= "string" then
+    error("expected argument of type string, got " .. type(str))
+  end
+  local res, idx = parse(str, next_char(str, 1, space_chars, true))
+  idx = next_char(str, idx, space_chars, true)
+  if idx <= #str then
+    decode_error(str, idx, "trailing garbage")
+  end
+  return res
+end
+
+
+return json

Capy64/Assets/Lua/CapyOS/sys/lib/keys.lua

@@ -0,0 +1,179 @@
+local keys = {
+    none = 0,
+    back = 8,
+    tab = 9,
+    enter = 13,
+    pause = 19,
+    caps_lock = 20,
+    kana = 21,
+    kanji = 25,
+    escape = 27,
+    ime_convert = 28,
+    ime_no_convert = 29,
+    space = 32,
+    page_up = 33,
+    page_down = 34,
+    ["end"] = 35,
+    home = 36,
+    left = 37,
+    up = 38,
+    right = 39,
+    down = 40,
+    select = 41,
+    print = 42,
+    execute = 43,
+    print_screen = 44,
+    insert = 45,
+    delete = 46,
+    help = 47,
+    zero = 48,
+    one = 49,
+    two = 50,
+    three = 51,
+    four = 52,
+    five = 53,
+    six = 54,
+    seven = 55,
+    eight = 56,
+    nine = 57,
+    a = 65,
+    b = 66,
+    c = 67,
+    d = 68,
+    e = 69,
+    f = 70,
+    g = 71,
+    h = 72,
+    i = 73,
+    j = 74,
+    k = 75,
+    l = 76,
+    m = 77,
+    n = 78,
+    o = 79,
+    p = 80,
+    q = 81,
+    r = 82,
+    s = 83,
+    t = 84,
+    u = 85,
+    v = 86,
+    w = 87,
+    x = 88,
+    y = 89,
+    z = 90,
+    left_windows = 91,
+    right_windows = 92,
+    apps = 93,
+    sleep = 95,
+    num_pad0 = 96,
+    num_pad1 = 97,
+    num_pad2 = 98,
+    num_pad3 = 99,
+    num_pad4 = 100,
+    num_pad5 = 101,
+    num_pad6 = 102,
+    num_pad7 = 103,
+    num_pad8 = 104,
+    num_pad9 = 105,
+    multiply = 106,
+    add = 107,
+    separator = 108,
+    subtract = 109,
+    decimal = 110,
+    divide = 111,
+    f1 = 112,
+    f2 = 113,
+    f3 = 114,
+    f4 = 115,
+    f5 = 116,
+    f6 = 117,
+    f7 = 118,
+    f8 = 119,
+    f9 = 120,
+    f10 = 121,
+    f11 = 122,
+    f12 = 123,
+    f13 = 124,
+    f14 = 125,
+    f15 = 126,
+    f16 = 127,
+    f17 = 128,
+    f18 = 129,
+    f19 = 130,
+    f20 = 131,
+    f21 = 132,
+    f22 = 133,
+    f23 = 134,
+    f24 = 135,
+    num_lock = 144,
+    scroll = 145,
+    left_shift = 160,
+    right_shift = 161,
+    left_control = 162,
+    right_control = 163,
+    left_alt = 164,
+    right_alt = 165,
+    browser_back = 166,
+    browser_forward = 167,
+    browser_refresh = 168,
+    browser_stop = 169,
+    browser_search = 170,
+    browser_favorites = 171,
+    browser_home = 172,
+    volume_mute = 173,
+    volume_down = 174,
+    volume_up = 175,
+    media_next_track = 176,
+    media_previous_track = 177,
+    media_stop = 178,
+    media_play_pause = 179,
+    launch_mail = 180,
+    select_media = 181,
+    launch_application1 = 182,
+    launch_application2 = 183,
+    semicolon = 186,
+    plus = 187,
+    comma = 188,
+    minus = 189,
+    period = 190,
+    question = 191,
+    tilde = 192,
+    chat_pad_green = 202,
+    chat_pad_orange = 203,
+    open_brackets = 219,
+    pipe = 220,
+    close_brackets = 221,
+    quotes = 222,
+    oem8 = 223,
+    backslash = 226,
+    process_key = 229,
+    copy = 242,
+    auto = 243,
+    enl_w = 244,
+    attn = 246,
+    crsel = 247,
+    exsel = 248,
+    erase_eof = 249,
+    play = 250,
+    zoom = 251,
+    pa1 = 253,
+    clear = 254,
+}
+
+keys.mods = {
+    none = 0,
+    left_shift = 1,
+    right_shift = 2,
+    left_alt = 4,
+    right_alt = 8,
+    left_control = 16,
+    right_control = 32,
+}
+
+keys.mods.shift = keys.mods.left_shift | keys.mods.right_shift
+keys.mods.alt = keys.mods.left_alt | keys.mods.right_alt
+keys.mods.control = keys.mods.left_control | keys.mods.right_control
+keys.mods.ctrl = keys.mods.control
+
+return keys

Capy64/Assets/Lua/CapyOS/sys/lib/lib.lua

@@ -0,0 +1,3 @@
+local x = math.random()
+
+return x

Capy64/Assets/Lua/CapyOS/sys/lib/parallel.lua

@@ -0,0 +1,61 @@
+local expect = require("expect")
+
+local parallel = {}
+
+local function contains(array, value)
+    for k, v in pairs(array) do
+        if v == value then
+            return true
+        end
+    end
+    return false
+end
+
+local function run(threads, exitOnAny)
+    local alive = #threads
+    local filters = {}
+    local ev = {}
+    while true do
+        for i, thread in pairs(threads) do
+            if not filters[i] or #filters[i] == 0 or contains(filters[i], ev[1]) or ev[1] == "interrupt" then
+                local pars = table.pack(coroutine.resume(thread, table.unpack(ev)))
+                if pars[1] then
+                    filters[i] = table.pack(table.unpack(pars, 2))
+                else
+                    error(pars[2], 0)
+                end
+            end
+
+            if coroutine.status(thread) == "dead" then
+                alive = alive - 1
+                if exitOnAny or alive <= 0 then
+                    return
+                end
+            end
+        end
+
+        ev = table.pack(coroutine.yield())
+    end
+end
+
+function parallel.waitForAll(...)
+    local threads = {}
+    for k, v in ipairs({ ... }) do
+        expect(k, v, "function")
+        table.insert(threads, coroutine.create(v))
+    end
+
+    return run(threads, false)
+end
+
+function parallel.waitForAny(...)
+    local threads = {}
+    for k, v in ipairs({ ... }) do
+        expect(k, v, "function")
+        table.insert(threads, coroutine.create(v))
+    end
+
+    return run(threads, true)
+end
+
+return parallel

Capy64/Assets/Lua/CapyOS/sys/lib/scheduler.lua

@@ -0,0 +1,182 @@
+local expect = require("expect").expect
+local tableutils = require("tableutils")
+local event = require("event")
+
+local scheduler = {}
+
+local function contains(array, value)
+    for k, v in pairs(array) do
+        if v == value then
+            return true
+        end
+    end
+    return false
+end
+
+local tasks = {}
+local processes = 0
+
+local Task = {}
+local TaskMeta = {
+    __index = Task,
+    __name = "OS_TASK",
+    __tostring = function(self)
+        return string.format("OS_TASK[%s]: %d", self.source or "", self.pid or 0)
+    end,
+}
+local function newTask()
+    local task = {}
+    return setmetatable(task, TaskMeta)
+end
+
+function Task:queue(eventName, ...)
+    expect(1, eventName, "string")
+    event.push("scheduler", self.pid, eventName, ...)
+end
+
+local function findParent()
+    local i = 3
+
+    while true do
+        local info = debug.getinfo(i)
+        if not info then
+            break
+        end
+
+        for pid, task in pairs(tasks) do
+            if task.uuid == tostring(info.func) then
+                return task
+            end
+        end
+
+        i = i + 1
+    end
+
+    return nil
+end
+
+local function cascadeKill(pid, err)
+    local task = tasks[pid]
+    if not task then
+        return
+    end
+    for i, cpid in ipairs(task.children) do
+        cascadeKill(cpid, err)
+    end
+    if task.parent then
+        local parent = tasks[task.parent]
+        if parent then
+            local index = tableutils.find(parent.children, task.pid)
+            table.remove(parent.children, index)
+            parent:queue("scheduler_task_end", task, err == nil, err)
+        end
+    else
+        if err then
+            error(err, 0)
+        end
+    end
+    if task then
+        task.killed = true
+        coroutine.close(task.thread)
+        tasks[pid] = nil
+        processes = processes - 1
+    end
+end
+
+local function resumeTask(task, yieldPars)
+    local pars = table.pack(coroutine.resume(task.thread, table.unpack(yieldPars)))
+    if pars[1] then
+        task.filters = table.pack(table.unpack(pars, 2))
+        return coroutine.status(task.thread) ~= "dead"
+    else
+        cascadeKill(task.pid, pars[2])
+        return false
+    end
+end
+
+function scheduler.spawn(func, options)
+    expect(1, func, "function")
+    expect(2, options, "nil", "table")
+
+    options = options or {}
+    options.args = options.args or {}
+
+    local source = debug.getinfo(2)
+
+    local task = newTask()
+    local pid = #tasks + 1
+    task.pid = pid
+    task.options = options
+    task.source = source.source
+    task.uuid = tostring(func)
+    task.thread = coroutine.create(func)
+    local parent = findParent()
+    if parent then
+        task.parent = parent.pid
+        table.insert(parent.children, pid)
+    end
+    task.filters = {}
+    task.children = {}
+    task.eventQueue = {}
+    task.skip = true
+
+    tasks[pid] = task
+
+    processes = processes + 1
+
+    return task, resumeTask(task, task.options.args)
+end
+
+function scheduler.kill(pid)
+    expect(1, pid, "number")
+    cascadeKill(pid)
+end
+
+function scheduler.ipc(pid, ...)
+    expect(1, pid, "number")
+    if not tasks[pid] then
+        error("process by pid " .. pid .. " does not exist.", 2)
+    end
+
+    local sender = findParent()
+    tasks[pid]:queue("ipc_message", sender, ...)
+end
+
+local running = false
+function scheduler.init()
+    if running then
+        error("scheduler already running", 2)
+    end
+    running = true
+
+    local ev = { n = 0 }
+    while processes > 0 do
+        for pid, task in pairs(tasks) do
+            local yieldPars = ev
+            if ev[1] == "scheduler" and ev[2] == pid then
+                yieldPars = table.pack(table.unpack(ev, 3))
+            end
+            if yieldPars[1] ~= "scheduler" and not task.filters or #task.filters == 0 or contains(task.filters, yieldPars[1]) or yieldPars[1] == "interrupt" then
+                if task.skip then
+                    task.skip = false
+                else
+                    resumeTask(task, yieldPars)
+                end
+            end
+
+            if coroutine.status(task.thread) == "dead" then
+                cascadeKill(pid)
+            end
+        end
+
+        if processes <= 0 then
+            break
+        end
+
+        ev = table.pack(coroutine.yield())
+    end
+
+    running = false
+end
+
+return scheduler

Capy64/Assets/Lua/CapyOS/sys/lib/shell/package.lua

@@ -0,0 +1,112 @@
+local expect = require("expect").expect
+local fs = require("fs")
+local nativePackage = package
+
+local function copyTable(source, target)
+    target = target or {}
+
+    for k, v in pairs(source) do
+        target[k] = v
+    end
+
+    return target
+end
+
+local hostPackages = copyTable(nativePackage._host)
+
+local function createPreloadSearcher(envPackage)
+    return function(name)
+        if not envPackage.preload[name] then
+            return string.format("no field package.preload['%s']", name)
+        end
+        return envPackage.preload[name], ":preload:"
+    end
+end
+
+local function createLoaderSearcher(envPackage)
+    return function(name)
+        local path, err = envPackage.searchpath(name, envPackage.path)
+
+        if not path then
+            return err
+        end
+
+        local func, err = loadfile(path)
+        if not func then
+            return string.format("error loading module '%s' from file '%s':\t%s", name, path, err)
+        end
+
+        return func, path
+    end
+end
+
+local function createEnvironment(filePath)
+    local envPackage = {
+        cpath = nativePackage.cpath,
+        searchpath = nativePackage.searchpath,
+        config = nativePackage.config,
+        searchers = {},
+        loaded = {},
+        preload = {},
+    }
+
+    local dirName = fs.getDir(filePath)
+    --envPackage.path = string.format("%s/?.lua;%s/?/init.lua;", dirName, dirName) .. nativePackage.path
+    envPackage.path = nativePackage.path
+
+    envPackage.searchers[1] = createPreloadSearcher(envPackage)
+    envPackage.searchers[2] = createLoaderSearcher(envPackage)
+
+    local function envRequire(modname)
+        expect(1, modname, "string", "number")
+        modname = tostring(modname)
+    
+        if envPackage.loaded[modname] then
+            return envPackage.loaded[modname]
+        end
+    
+        local errorOutput = ""
+        local libFunction, libPath
+        for i = 1, #envPackage.searchers do
+            local par, path = envPackage.searchers[i](modname)
+            if type(par) == "function" then
+                libFunction, libPath = par, path
+                break
+            else
+                errorOutput = errorOutput .. "\n\t" .. par
+            end
+        end
+    
+        if not libFunction then
+            error(string.format("module '%s' not found:%s", modname, errorOutput), 2)
+        end
+    
+        local ok, par = pcall(libFunction)
+        if not ok then
+            error(par, 0)
+        end
+    
+        if par == nil then
+            envPackage.loaded[modname] = true
+            return true
+        end
+    
+        envPackage.loaded[modname] = par
+    
+        return par, libPath
+    end
+
+    copyTable(hostPackages, envPackage.loaded)
+    envPackage.loaded.package = envPackage
+
+    local env_G = copyTable(envPackage.loaded._G or _G)
+    envPackage.loaded._G = env_G
+    env_G._G = env_G
+
+    envPackage.loaded._G.package = envPackage
+    envPackage.loaded._G.require = envRequire
+
+    return envPackage, envRequire
+end
+
+return createEnvironment

Capy64/Assets/Lua/CapyOS/sys/lib/tableutils.lua

@@ -0,0 +1,87 @@
+local expect = require("expect").expect
+local tableutils = {}
+
+local function serialize(data, circular)
+    expect(1, data, "string", "table", "number", "boolean", "nil")
+    if type(data) == "table" then
+        if not circular then
+            circular = {}
+        end
+        local output = "{"
+        for k, v in pairs(data) do
+            if type(v) == "table" then
+                local name = tostring(v)
+                if circular[name] then
+                    error("circular reference in table", 2)
+                end
+                circular[name] = true
+            end
+            output = output .. string.format("[%q] = %s,", k, serialize(v, circular))
+        end
+        output = output .. "}"
+        return output
+    else
+        return string.format("%q", data)
+    end
+end
+
+function tableutils.serialize(data)
+    expect(1, data, "string", "table", "number", "boolean", "nil")
+    return serialize(data)
+end
+
+function tableutils.deserialize(data)
+    local func, err = load("return " .. data, "=tableutils", "t", {})
+    if not func then
+        error(err, 2)
+    end
+    return func()
+end
+
+local function prettyvalue(value)
+    if type(value) == "table" or type(value) == "function" or type(value) == "thread" or type(value) == "userdata" or type(value) == "number" then
+        return tostring(value)
+    else
+        return string.format("%q", value)
+    end
+end
+
+function tableutils.pretty(data)
+    if type(data) == "table" then
+        local output = "{"
+
+        local index = 0
+        for k, v in pairs(data) do
+            local value = prettyvalue(v)
+            
+            if type(k) == "number" and k - 1 == index then
+                index = index + 1
+                output = output .. string.format("\n  %s,", value)
+            elseif type(k) == "string" and k:match("^[%a_][%w_]*$") then
+                output = output .. string.format("\n  %s = %s,", k, value)
+            else
+                output = output .. string.format("\n  [%s] = %s,", prettyvalue(k), value)
+            end
+        end
+        if output == "{" then
+            return "{}"
+        end
+        output = output .. "\n}"
+
+        return output
+    else
+        return prettyvalue(data)
+    end
+end
+
+function tableutils.find(tbl, element)
+    for i = 1, #tbl do
+        if tbl[i] == element then
+            return i
+        end
+    end
+
+    return nil
+end
+
+return tableutils

Capy64/Assets/Lua/CapyOS/sys/share/help/index

@@ -0,0 +1,2 @@
+Welcome to CapyOS!
+Run "programs" to get a list of available programs.

Capy64/Assets/Lua/CapyOS/sys/share/help/license

@@ -0,0 +1,12 @@
+CapyOS and Capy64 are licensed under the Apache 2.0 Public License.
+https://capy64.alexdevs.me/
+https://github.com/Ale32bit/Capy64
+
+Some CapyOS components include code from the CC Recrafted project.
+https://github.com/Ocawesome101/recrafted
+
+Some CapyOS components may include code from CC: Tweaked.
+https://github.com/CC-Tweaked/CC-Tweaked
+
+json.lua by rxi is licensed under the MIT License.
+https://github.com/rxi/json.lua

Capy64/Assets/Lua/CapyOS/sys/share/motd.txt

@@ -0,0 +1,3 @@
+You can get started with Lua by following this manual: https://www.lua.org/manual/
+Learn more about Capy64 by following the documentation: https://capy64.alexdevs.me/
+Found a bug or would like to suggest a feature? https://github.com/Ale32bit/Capy64/issues

Capy64/Assets/Lua/README.txt

@@ -0,0 +1,5 @@
+If you are looking for your data directory look in:
+
+Windows: %APPDATA%\Capy64\data
+Mac: $HOME/.local/share/Capy64/data
+Linux: $HOME/.local/share/Capy64/data

Capy64/Assets/Lua/bios.lua

@@ -1,4 +1,4 @@
--- This file is part of Capy64 - https://github.com/Capy64/Capy64
+-- This file is part of Capy64 - https://github.com/Capy64/Capy64
 -- Copyright 2023 Alessandro "AlexDevs" Proto
 --
 -- Licensed under the Apache License, Version 2.0 (the "License").
@@ -19,23 +19,22 @@ local gpu = require("gpu")
 local fs = require("fs")
 local machine = require("machine")
 local audio = require("audio")
-local http = require("http")
 local event = require("event")
 
-
-local INDEX_URL = "https://raw.github.com/Ale32bit/CapyOS/deploy/index.json"
-local JSON_URL = "https://raw.github.com/Ale32bit/CapyOS/main/lib/json.lua"
-
-local bootSleep = 2000
+local bootSleep = 2
 local bg = 0x0
 local fg = 0xffffff
+local setupbg = 0x0608a6
+local setupfg = 0xffffff
+local accent = 0xffea00
 
 term.setForeground(fg)
 term.setBackground(bg)
 term.clear()
 
-term.setSize(51, 19)
-gpu.setScale(2)
+if term.isResizable() then
+	term.setSize(53, 20)
+end
 
 local w, h = term.getSize()
 
@@ -57,19 +56,20 @@ local function writeCenter(text)
 end
 
 local function drawVendorImage()
-	if not fs.exists("/boot/vendor.bmp") then
+	if not fs.exists("/sys/vendor.bmp") then
 		return
 	end
 
 	local w, h = gpu.getSize()
 	local ok, err = pcall(function()
-		local buffer<close>, width, height = gpu.loadImage("/boot/vendor.bmp")
+		local task<close> = gpu.loadImageAsync("/sys/vendor.bmp")
+		local buffer<close> = task:await()
 
 		local x, y = 
-			math.ceil((w / 2) - (width / 2)),
-			math.ceil((h / 2) - (height / 2))
+			math.ceil((w / 2) - (buffer.width / 2)),
+			math.ceil((h / 2) - (buffer.height / 2))
 
-		gpu.drawBuffer(buffer, x, y, width, height)
+		gpu.drawBuffer(buffer, x, y)
 	end)
 
 	if not ok then
@@ -95,71 +95,65 @@ local function printError( text )
 	term.setForeground(0xffffff)
 end
 
-local function hget(url, headers)
-	local requestId = http.requestAsync(url, nil, headers, {binary = true})
-
-	local ev, rId, par, info
-	repeat
-		ev, rId, par, info = event.pull("http_response", "http_failure")
-	until rId == requestId
-
-	if ev == "http_failure" then
-		return nil, par
-	end
-	local content = par:read("a")
-	par:close()
-	return content, info
-end
-
 local function promptKey()
 	print("Press any key to continue")
 	event.pull("key_down")
 end
 
-local function installOS()
-	term.clear()
-	term.setPos(1, 1)
-
-	print("Installing CapyOS...")
-
-	local jsonLib, par = hget(JSON_URL)
-	if not jsonLib then
-		printError(par)
-		promptKey()
-		return
+local function alert(...)
+	local args = {...}
+	table.insert(args, "[ OK ]")
+	local lines = {}
+	local width = 0
+	local padding = 1
+	for k, v in ipairs(args) do
+		lines[k] = tostring(v)
+		width = math.max(width, #tostring(v))
 	end
 
-	local json = load(jsonLib)()
-	local indexData, par = hget(INDEX_URL)
-	if not indexData then
-		printError(par)
-		promptKey()
-		return
+	lines[#lines] = nil
+
+	local okPad = string.rep(" ", (width - #args[#args]) // 2)
+	local okLine = string.format("%s%s", okPad, args[#args])
+
+	local w, h = term.getSize()
+	local cx, cy = w//2, h//2
+	local dx, dy = cx - (width + padding * 2) // 2, cy - #lines//2 - 1
+
+	local pad = string.rep(" ", padding)
+	local emptyLine = string.format("\u{258C}%s%s%s\u{2590}", pad, string.rep(" ", width), pad)
+
+	term.setPos(dx, dy)
+	print("\u{259B}" .. string.rep("\u{2580}", width + padding * 2) .. "\u{259C}")
+	for k, v in ipairs(lines) do
+		term.setPos(dx, dy + k)
+		local space = string.rep(" ", width - #v)
+		print(string.format("\u{258C}%s%s%s%s\u{2590}", pad, v, space, pad))
 	end
-	local index = json.decode(indexData)
+	term.setPos(dx, dy + #lines + 1)
+	print(emptyLine)
+	term.setPos(dx, dy + #lines + 2)
+	local space = string.rep(" ", width - #okLine)
+	term.write(string.format("\u{258C}%s", pad))
+	term.setForeground(accent)
+	term.write(okLine)
+	term.setForeground(setupfg)
+	print(string.format("%s%s\u{2590}", space, pad))
+	term.setPos(dx, dy + #lines + 3)
+	print("\u{2599}" .. string.rep("\u{2584}", width + padding * 2) .. "\u{259F}")
 
-	for i, v in ipairs(index) do
-		local dirname = fs.getDir(v.path) 
-		if not fs.exists(dirname) then
-			fs.makeDir(dirname)
-		end
-		print("Downloading " .. v.path)
-		local fileContent = hget(v.raw_url)
-		local f = fs.open(v.path, "w")
-		f:write(fileContent)
-		f:close()
-		print("Written to " .. v.path)
-	end
-
-	flagInstalled()
-
-	print("CapyOS installed!")
-	promptKey()
+	local _, key, keyname
+	repeat
+		_, key, keyname = event.pull("key_down")
+	until keyname == "enter" or keyname == "escape"
 end
 
-local function toggleConsole()
-	local status = getConsole()
-	setConsole(not status)
+local function installDefaultOS()
+	if fs.exists("/sys") then
+		fs.delete("/sys", true)
+	end
+	installOS()
+	alert("Default OS installed!")
 end
 
 term.setBlink(false)
@@ -170,14 +164,11 @@ local function setupScreen()
 			"Open data folder",
 			openDataFolder,
 		},
-		{
-			"Toggle console window",
-			toggleConsole,
-		},
 		{
 			"Install default OS",
-			installOS,
+			installDefaultOS,
 		},
+		{},
 		{
 			"Exit setup",
 			exit,
@@ -189,26 +180,40 @@ local function setupScreen()
 	}
 
 	local selection = 1
-	local function redraw()
-		term.setForeground(fg)
-		term.setBackground(bg)
+	local function redraw(noDrawSel)
+		local w, h = term.getSize()
+		term.setForeground(setupfg)
+		term.setBackground(setupbg)
 		term.clear()
 		term.setPos(1,2)
 		writeCenter("Capy64 Setup")
 
 		term.setPos(1,3)
 
+		term.setForeground(accent)
+
 		for k, v in ipairs(options) do
 			local _, y = term.getPos()
 			term.setPos(1, y + 1)
 			term.clearLine()
 
-			if selection == k then
-				writeCenter("[ " .. v[1] .. " ]")
-			else
-				writeCenter(v[1])
+			if #v > 0 then
+				if selection == k and not noDrawSel then
+					writeCenter("[ " .. v[1] .. " ]")
+				else
+					writeCenter(v[1])
+				end
 			end
 		end
+
+		term.setForeground(setupfg)
+
+		term.setPos(1, h - 2)
+		term.write("\u{2190}\u{2191}\u{2192}\u{2193}: Move")
+		term.setPos(1, h - 1)
+		term.write("Escape: Exit")
+		term.setPos(1, h)
+		term.write("Enter: Select")
 	end
 
 	while true do
@@ -216,9 +221,16 @@ local function setupScreen()
 		local ev = { coroutine.yield("key_down") }
 		if ev[3] == "up" then
 			selection = selection - 1
+			if options[selection] and #options[selection] == 0 then
+				selection = selection - 1
+			end
 		elseif ev[3] == "down" then
 			selection = selection + 1
+			if options[selection] and #options[selection] == 0 then
+				selection = selection + 1
+			end
 		elseif ev[3] == "enter" then
+			redraw(true)
 			options[selection][2]()
 		elseif ev[3] == "escape" then
 			exit()
@@ -239,7 +251,7 @@ local function bootScreen()
 	term.setPos(1,2)
 	writeCenter("Capy64")
 	term.setPos(1,4)
-	writeCenter("Powered by Capybaras")
+	writeCenter("(c) 2023 AlexDevs")
 
 	term.setPos(1, h - 1)
 	writeCenter("Press F2 to open setup")
@@ -258,10 +270,6 @@ end
 
 audio.beep(1000, 0.2, 0.2, "square")
 
-if shouldInstallOS() then
-	installOS()
-end
-
 bootScreen()
 
 term.clear()

Capy64/Assets/Lua/firmware.lua

@@ -0,0 +1,51 @@
+-- This file is part of Capy64 - https://github.com/Capy64/Capy64
+-- Copyright 2023 Alessandro "AlexDevs" Proto
+--
+-- Licensed under the Apache License, Version 2.0 (the "License").
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+
+local event = require("event")
+local coroutine = coroutine
+
+-- Declare event functions
+function event.pull(...)
+    local ev = table.pack(coroutine.yield(...))
+    if ev[1] == "interrupt" then
+        error("Interrupted", 2)
+    end
+    return table.unpack(ev)
+end
+
+function event.pullRaw(...)
+    return coroutine.yield(...)
+end
+
+-- Set task awaiter
+
+local function awaiter(task)
+    local status = task:getStatus()
+    local uuid = task:getID()
+    if status == "running" then
+        local _, taskId, result, err
+        repeat
+            _, taskId, result, err = event.pull("task_finish")
+        until taskId == uuid
+        return result, err
+    elseif status == "succeeded" then
+        return task:getResult(), nil
+    elseif status == "failed" then
+        return nil, task:getError()
+    end
+end
+
+-- Second argument freezes the awaiter function, so it cannot be modified
+event.setAwaiter(awaiter, true)

Capy64/Assets/default.json

@@ -1,4 +1,9 @@
 {
+  "EngineMode": 0,
+  "SafeMode": false,
+  "Window": {
+    "Scale": 2
+  },
   "HTTP": {
     "Enable": true,
     "Blacklist": [],

Capy64/Capy64.cs

@@ -20,37 +20,83 @@ using Capy64.Extensions;
 using Capy64.Integrations;
 using Capy64.PluginManager;
 using Capy64.Runtime;
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using MonoGame.Extended;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
 using static Capy64.Utils;
 
 namespace Capy64;
 
-public class Capy64 : Game, IGame
+public enum EngineMode
 {
-    public const string Version = "0.0.9-alpha";
-    public static string AppDataPath = Path.Combine(
-        Environment.GetFolderPath(
-            Environment.SpecialFolder.ApplicationData,
-            Environment.SpecialFolderOption.Create),
-        "Capy64");
+    Classic,
+    Free
+}
+
+public class Capy64 : Game
+{
+    public const string Version = "1.1.2-beta";
+
+    public static class DefaultParameters
+    {
+        public const int Width = 318;
+        public const int Height = 240;
+        public const float Scale = 2f;
+        public const float BorderMultiplier = 1.5f;
+        public static readonly EngineMode EngineMode = EngineMode.Classic;
+
+        public const int ClassicTickrate = 30;
+        public const int FreeTickrate = 60;
+    }
+
+    public static readonly string AssemblyPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+    public static readonly string AssetsPath = Path.Combine(AssemblyPath, "Assets");
+
+    public static string AppDataPath
+    {
+        get
+        {
+            string baseDir =
+                RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
+                    Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData,
+                        Environment.SpecialFolderOption.Create) :
+                RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ?
+                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData,
+                        Environment.SpecialFolderOption.Create) :
+                RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ?
+                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData,
+                        Environment.SpecialFolderOption.Create) :
+                "./";
+
+            return Path.Combine(baseDir, "Capy64");
+        }
+    }
+
     public static Capy64 Instance { get; private set; }
     public Capy64 Game => this;
+    public EngineMode EngineMode { get; private set; } = EngineMode.Classic;
     public IList<IComponent> NativePlugins { get; private set; }
     public IList<IComponent> Plugins { get; private set; }
-    public int Width { get; set; } = 400;
-    public int Height { get; set; } = 300;
-    public float Scale { get; set; } = 2f;
+    public int Width { get; set; } = DefaultParameters.Width;
+    public int Height { get; set; } = DefaultParameters.Height;
+    public float Scale { get; set; } = DefaultParameters.Scale;
     public Drawing Drawing { get; private set; }
     public Audio Audio { get; private set; }
     public LuaState LuaRuntime { get; set; }
     public Eventing.EventEmitter EventEmitter { get; private set; }
     public DiscordIntegration Discord { get; set; }
+    public int TickRate => tickrate;
+    public IConfiguration Configuration { get; private set; }
+
+    public Color BorderColor { get; set; } = Color.Black;
 
     public Borders Borders = new()
     {
@@ -59,21 +105,23 @@ public class Capy64 : Game, IGame
         Left = 0,
         Right = 0,
     };
+
     public SpriteBatch SpriteBatch;
 
 
     private readonly InputManager _inputManager;
     private RenderTarget2D renderTarget;
     private readonly GraphicsDeviceManager _graphics;
-    private IServiceProvider _serviceProvider;
     private ulong _totalTicks = 0;
+    private int tickrate = 0;
+    private int everyTick => 60 / tickrate;
 
     public Capy64()
     {
         Instance = this;
 
         _graphics = new GraphicsDeviceManager(this);
-        Content.RootDirectory = "Content";
+        //Content.RootDirectory = "Content";
         IsMouseVisible = true;
 
         EventEmitter = new();
@@ -82,9 +130,28 @@ public class Capy64 : Game, IGame
         Drawing = new();
     }
 
-    public void ConfigureServices(IServiceProvider serviceProvider)
+    public void SetEngineMode(EngineMode mode)
     {
-        _serviceProvider = serviceProvider;
+        switch (mode)
+        {
+            case EngineMode.Classic:
+                tickrate = DefaultParameters.ClassicTickrate;
+                Width = DefaultParameters.Width;
+                Height = DefaultParameters.Height;
+                Window.AllowUserResizing = false;
+                ResetBorder();
+
+                break;
+
+            case EngineMode.Free:
+                tickrate = DefaultParameters.FreeTickrate;
+                Window.AllowUserResizing = true;
+                break;
+        }
+
+        EngineMode = mode;
+
+        UpdateSize(true);
     }
 
     public void UpdateSize(bool resize = true)
@@ -92,7 +159,7 @@ public class Capy64 : Game, IGame
         if (resize)
         {
             _graphics.PreferredBackBufferWidth = (int)(Width * Scale) + Borders.Left + Borders.Right;
-            _graphics.PreferredBackBufferHeight = (int)(Height * Scale) + Borders.Top + Borders.Right;
+            _graphics.PreferredBackBufferHeight = (int)(Height * Scale) + Borders.Top + Borders.Bottom;
             _graphics.ApplyChanges();
         }
 
@@ -107,13 +174,18 @@ public class Capy64 : Game, IGame
         Drawing.Canvas = renderTarget;
 
         _inputManager.Texture = renderTarget;
-        _inputManager.WindowScale = Scale;
 
         EventEmitter.RaiseScreenSizeChange();
     }
 
     private void OnWindowSizeChange(object sender, EventArgs e)
     {
+        if (EngineMode == EngineMode.Classic)
+        {
+            UpdateSize(true);
+            return;
+        }
+
         var bounds = Window.ClientBounds;
 
         Width = (int)(bounds.Width / Scale);
@@ -129,19 +201,52 @@ public class Capy64 : Game, IGame
 
             Borders.Left = (int)Math.Floor(horizontal / 2d);
             Borders.Right = (int)Math.Ceiling(horizontal / 2d);
+
+            UpdateSize(false);
         }
         else
         {
-            Borders = new Borders();
+            ResetBorder();
+            UpdateSize();
         }
+    }
 
-        UpdateSize(false);
+    private void ResetBorder()
+    {
+        var size = (int)(Scale * DefaultParameters.BorderMultiplier);
+        Borders = new Borders
+        {
+            Top = size,
+            Bottom = size,
+            Left = size,
+            Right = size
+        };
     }
 
     protected override void Initialize()
     {
+        var configBuilder = new ConfigurationBuilder();
+
+        var settingsPath = Path.Combine(AppDataPath, "settings.json");
+        if (!Directory.Exists(AppDataPath))
+        {
+            Directory.CreateDirectory(AppDataPath);
+        }
+        if (!File.Exists(settingsPath))
+        {
+            File.Copy(Path.Combine(AssetsPath, "default.json"), settingsPath);
+        }
+
+        configBuilder.AddJsonFile(Path.Combine(AssetsPath, "default.json"), false);
+        configBuilder.AddJsonFile(settingsPath, false);
+
+        Configuration = configBuilder.Build();
+
         Window.Title = "Capy64 " + Version;
 
+        Scale = Configuration.GetValue("Window:Scale", DefaultParameters.Scale);
+
+        ResetBorder();
         UpdateSize();
 
         Window.AllowUserResizing = true;
@@ -149,10 +254,14 @@ public class Capy64 : Game, IGame
 
         InactiveSleepTime = new TimeSpan(0);
 
+        SetEngineMode(Configuration.GetValue<EngineMode>("EngineMode", DefaultParameters.EngineMode));
+
         Audio = new Audio();
 
         NativePlugins = GetNativePlugins();
-        Plugins = PluginLoader.LoadAllPlugins("plugins", _serviceProvider);
+        var safeMode = Configuration.GetValue("SafeMode", false);
+        if (!safeMode)
+            Plugins = PluginLoader.LoadAllPlugins(Path.Combine(AppDataPath, "plugins"));
 
         EventEmitter.RaiseInit();
 
@@ -170,9 +279,10 @@ public class Capy64 : Game, IGame
 
         foreach (var type in types)
         {
-            var instance = (IComponent)ActivatorUtilities.CreateInstance(_serviceProvider, type)!;
+            var instance = (IComponent)Activator.CreateInstance(type, this);
             plugins.Add(instance);
         }
+
         return plugins;
     }
 
@@ -192,7 +302,8 @@ public class Capy64 : Game, IGame
         EventEmitter.RaiseTick(new()
         {
             GameTime = gameTime,
-            TotalTicks = _totalTicks
+            TotalTicks = _totalTicks,
+            IsActiveTick = (int)_totalTicks % everyTick == 0,
         });
 
         Drawing.End();
@@ -205,7 +316,14 @@ public class Capy64 : Game, IGame
     protected override void Draw(GameTime gameTime)
     {
         SpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp);
-        SpriteBatch.Draw(renderTarget, new(Borders.Left, Borders.Top), null, Color.White, 0f, Vector2.Zero, Scale, SpriteEffects.None, 0);
+        GraphicsDevice.Clear(BorderColor);
+
+        SpriteBatch.DrawRectangle(renderTarget.Bounds.Location.ToVector2() + new Vector2(Borders.Left, Borders.Top),
+            new Size2(renderTarget.Bounds.Width * Scale, renderTarget.Bounds.Height * Scale), Color.Black,
+            Math.Min(renderTarget.Bounds.Width, renderTarget.Bounds.Height), 0);
+
+        SpriteBatch.Draw(renderTarget, new(Borders.Left, Borders.Top), null, Color.White, 0f, Vector2.Zero, Scale,
+            SpriteEffects.None, 0);
 
         EventEmitter.RaiseOverlay(new()
         {

Capy64/Capy64.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 	<PropertyGroup>
 		<OutputType>WinExe</OutputType>
-		<TargetFramework>net7.0</TargetFramework>
+		<TargetFramework>net8.0</TargetFramework>
 		<RollForward>Major</RollForward>
 		<PublishReadyToRun>false</PublishReadyToRun>
 		<TieredCompilation>false</TieredCompilation>
@@ -26,9 +26,9 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<None Update="Assets\Lua/**">
+		<Content Include="Assets\Lua\**">
 			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-		</None>
+		</Content>
 	</ItemGroup>
 	<ItemGroup>
 		<None Include="..\LICENSE">
@@ -37,25 +37,33 @@
 		</None>
 	</ItemGroup>
 	<ItemGroup>
-		<PackageReference Include="DiscordRichPresence" Version="1.1.3.18" />
-		<PackageReference Include="FontStashSharp.MonoGame" Version="1.2.8" />
-		<PackageReference Include="KeraLua" Version="1.3.3" />
-		<PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.1" />
+		<PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
+		<PackageReference Include="FontStashSharp.MonoGame" Version="1.3.6" />
+		<PackageReference Include="KeraLua" Version="1.4.1" />
+		<PackageReference Include="Microsoft.Extensions.Configuration" Version="8.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.1" />
+		<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="8.0.0" />
 		<PackageReference Include="MonoGame.Extended.Graphics" Version="3.8.0" />
 		<PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.1.303" />
 		<PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.1.303" />
-		<PackageReference Include="System.ComponentModel.Composition" Version="7.0.0" />
 	</ItemGroup>
 	<ItemGroup>
-		<None Update="Assets\bios.lua">
-			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-		</None>
+		<EditorConfigFiles Remove="C:\Users\Alex\source\repos\Capy64\Capy64\Capy64\.editorconfig" />
 	</ItemGroup>
-	<Target Name="RestoreDotnetTools" BeforeTargets="Restore">
-		<Message Text="Restoring dotnet tools" Importance="High" />
-		<Exec Command="dotnet tool restore" />
-	</Target>
 	<ItemGroup>
-	  <EditorConfigFiles Remove="C:\Users\Alex\source\repos\Capy64\Capy64\Capy64\.editorconfig" />
+		<Folder Include="Assets\Lua\" />
 	</ItemGroup>
+
+	<PropertyGroup Condition=" '$(OS)' == 'Windows_NT' ">
+		<DefineConstants>_WINDOWS</DefineConstants>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Linux)))' ">
+		<DefineConstants>_LINUX</DefineConstants>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::OSX)))' ">
+		<DefineConstants>_OSX</DefineConstants>
+	</PropertyGroup>
 </Project>

Capy64/Content/Content.mgcb

@@ -1,15 +0,0 @@
-
-#----------------------------- Global Properties ----------------------------#
-
-/outputDir:bin/$(Platform)
-/intermediateDir:obj/$(Platform)
-/platform:DesktopGL
-/config:
-/profile:Reach
-/compress:False
-
-#-------------------------------- References --------------------------------#
-
-
-#---------------------------------- Content ---------------------------------#
-

Capy64/Core/Audio.cs

@@ -29,12 +29,12 @@ public class Audio : IDisposable
         Noise
     }
 
-    public const int SampleRate = 16000;
+    public const int SampleRate = 24000;
     public const int HQSampleRate = 48000;
     public const AudioChannels AudioChannel = AudioChannels.Mono;
-    public const int ChannelsCount = 5;
+    public const int ChannelsCount = 8;
     public readonly DynamicSoundEffectInstance[] Channels = new DynamicSoundEffectInstance[ChannelsCount];
-    private bool[] freeChannels = new bool[ChannelsCount];
+    private readonly bool[] freeChannels = new bool[ChannelsCount];
 
     public readonly DynamicSoundEffectInstance HQChannel = new(HQSampleRate, AudioChannel);
 
@@ -126,6 +126,7 @@ public class Audio : IDisposable
 
     public TimeSpan SubmitHQ(byte[] buffer)
     {
+        
         HQChannel.SubmitBuffer(buffer);
         return HQChannel.GetSampleDuration(buffer.Length);
     }

Capy64/Core/Drawing.cs

@@ -31,7 +31,7 @@ public class Drawing : IDisposable
     private Texture2D _whitePixel;
     private RenderTarget2D _canvas;
     private bool _isDrawing;
-    private HashSet<Texture2D> _disposeTextures = new();
+    private readonly HashSet<Texture2D> _disposeTextures = new();
     public RenderTarget2D Canvas
     {
         get => _canvas;
@@ -54,7 +54,7 @@ public class Drawing : IDisposable
     public Drawing()
     {
         _fontSystem = new FontSystem();
-        _fontSystem.AddFont(File.ReadAllBytes(@"Assets/font.ttf"));
+        _fontSystem.AddFont(File.ReadAllBytes(Path.Combine(Capy64.AssetsPath, "font.ttf")));
     }
 
     public void Begin()
@@ -184,6 +184,7 @@ public class Drawing : IDisposable
     public void Clear(Color? color = default)
     {
         Color finalColor = color ?? Color.Black;
+        Capy64.Instance.BorderColor = finalColor;
         _graphicsDevice.Clear(finalColor);
     }
 
@@ -200,7 +201,7 @@ public class Drawing : IDisposable
         _spriteBatch.Draw(_whitePixel, position3, null, color, rotation, Vector2.Zero, scale, SpriteEffects.None, layerDepth);
     }
 
-    public void DrawBuffer(uint[] buffer, Rectangle rect, Rectangle? source = null, Color? color = null, float rotation = 0f, Vector2? origin = null, float scale = 1f, SpriteEffects spriteEffects = 0)
+    public void DrawBuffer(uint[] buffer, Rectangle rect, Rectangle? source = null, Color? color = null, float rotation = 0f, Vector2? origin = null, Vector2? scale = null, SpriteEffects spriteEffects = 0)
     {
         var texture = new Texture2D(_graphicsDevice, rect.Width, rect.Height, false, SurfaceFormat.Color);
         texture.SetData(buffer);
@@ -212,7 +213,7 @@ public class Drawing : IDisposable
             color ?? Color.White, // Color
             rotation, // Rotation
             origin ?? Vector2.Zero, // Origin
-            scale, // Scale
+            scale ?? Vector2.One, // Scale
             spriteEffects, // Flip effects
             0f // layer depth
         );

Capy64/Eventing/Events/TickEvent.cs

@@ -22,4 +22,5 @@ public class TickEvent : EventArgs
 {
     public GameTime GameTime { get; set; }
     public ulong TotalTicks { get; set; }
+    public bool IsActiveTick { get; set; }
 }

Capy64/Eventing/InputManager.cs

@@ -52,7 +52,7 @@ public class InputManager
         Ctrl = LCtrl | RCtrl,
     }
 
-    private static Keys[] IgnoredTextInputKeys =
+    private static readonly Keys[] IgnoredTextInputKeys =
     {
         Keys.Enter,
         Keys.Back,
@@ -74,7 +74,7 @@ public class InputManager
     };
 
     public Texture2D Texture { get; set; }
-    public float WindowScale { get; set; }
+    public static float WindowScale => Capy64.Instance.Scale;
     public const int MouseScrollDelta = 120;
 
     private Point mousePosition;
@@ -82,7 +82,7 @@ public class InputManager
     private int hMouseScroll;
 
     private Modifiers keyboardMods = 0;
-    private HashSet<Keys> pressedKeys = new();
+    private readonly HashSet<Keys> pressedKeys = new();
 
     private readonly Game _game;
     private readonly EventEmitter _eventEmitter;
@@ -113,7 +113,7 @@ public class InputManager
         if (!isActive)
             return;
 
-        var rawPosition = state.Position;
+        var rawPosition = state.Position - new Point(Capy64.Instance.Borders.Left, Capy64.Instance.Borders.Top);
         var pos = new Point((int)(rawPosition.X / WindowScale), (int)(rawPosition.Y / WindowScale)) + new Point(1, 1);
 
         if (pos.X < 1 || pos.Y < 1 || pos.X > Texture.Width || pos.Y > Texture.Height)

Capy64/Extensions/Bindings/SDL2.cs

@@ -20,32 +20,40 @@ namespace Capy64.Extensions.Bindings;
 
 public partial class SDL2
 {
-    private const string SDL = "SDL2.dll";
+#if _WINDOWS
+    private const string LibraryName = "SDL2.dll";
+#elif _LINUX
+    private const string LibraryName = "libSDL2-2.0.so.0";
+#elif _OSX
+    private const string LibraryName = "libSDL2.dylib";
+#else
+    private const string LibraryName = "SDL2";
+#endif
 
-    [LibraryImport(SDL)]
+    [LibraryImport(LibraryName)]
     [UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
     internal static partial void SDL_MaximizeWindow(IntPtr window);
 
-    [LibraryImport(SDL)]
+    [LibraryImport(LibraryName)]
     [UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
     internal static partial uint SDL_GetWindowFlags(IntPtr window);
 
-    [LibraryImport(SDL, EntryPoint = "SDL_GetClipboardText")]
+    [LibraryImport(LibraryName, EntryPoint = "SDL_GetClipboardText")]
     [UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
     internal static partial IntPtr Native_SDL_GetClipboardText();
 
     /// <summary>
     /// </summary>
     /// <returns>0 is false; 1 is true</returns>
-    [LibraryImport(SDL)]
+    [LibraryImport(LibraryName)]
     [UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
     internal static partial int SDL_HasClipboardText();
 
-    [LibraryImport(SDL, EntryPoint = "SDL_SetClipboardText", StringMarshalling = StringMarshalling.Utf8)]
+    [LibraryImport(LibraryName, EntryPoint = "SDL_SetClipboardText", StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
     internal static partial int Native_SDL_SetClipboardText(string contents);
 
-    [LibraryImport(SDL)]
+    [LibraryImport(LibraryName)]
     [UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
     internal static partial void SDL_free(IntPtr memblock);
 
@@ -97,7 +105,7 @@ public partial class SDL2
         }
         char* chars = stackalloc char[len];
         int strLen = System.Text.Encoding.UTF8.GetChars((byte*)s, len, chars, len);
-        string result = new string(chars, 0, strLen);
+        string result = new(chars, 0, strLen);
 #endif
 
         /* Some SDL functions will malloc, we have to free! */

Capy64/IGame.cs

@@ -1,49 +0,0 @@
-// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
-// Copyright 2023 Alessandro "AlexDevs" Proto
-//
-// Licensed under the Apache License, Version 2.0 (the "License").
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-using Capy64.API;
-using Capy64.Core;
-using Capy64.Integrations;
-using Capy64.Runtime;
-using Microsoft.Xna.Framework;
-using System;
-using System.Collections.Generic;
-
-namespace Capy64;
-
-public interface IGame
-{
-    Capy64 Game { get; }
-    IList<IComponent> NativePlugins { get; }
-    IList<IComponent> Plugins { get; }
-    GameWindow Window { get; }
-    Drawing Drawing { get; }
-    Audio Audio { get; }
-    LuaState LuaRuntime { get; set; }
-    Eventing.EventEmitter EventEmitter { get; }
-    void ConfigureServices(IServiceProvider serviceProvider);
-
-    int Width { get; set; }
-    int Height { get; set; }
-    float Scale { get; set; }
-    void UpdateSize(bool resize = true);
-
-    event EventHandler<EventArgs> Exiting;
-    void Run();
-    void Exit();
-
-    // Integrations
-    DiscordIntegration Discord { get; }
-}

Capy64/Integrations/DiscordIntegration.cs

@@ -25,29 +25,35 @@ namespace Capy64.Integrations;
 public class DiscordIntegration : IComponent
 {
     public DiscordRpcClient Client { get; private set; }
+    public readonly bool Enabled;
     private readonly IConfiguration _configuration;
 
-    public DiscordIntegration(IConfiguration configuration)
+    public DiscordIntegration(Capy64 game)
     {
-        _configuration = configuration;
+        _configuration = game.Configuration;
 
         var discordConfig = _configuration.GetSection("Integrations:Discord");
-        Client = new(discordConfig["ApplicationId"]);
+        Enabled = discordConfig.GetValue("Enable", false);
 
-        Client.Logger = new ConsoleLogger() { Level = DiscordRPC.Logging.LogLevel.Warning };
+        Client = new(discordConfig["ApplicationId"])
+        {
+            Logger = new ConsoleLogger() { Level = LogLevel.Warning }
+        };
 
         Client.OnReady += OnReady;
 
         Capy64.Instance.Discord = this;
 
-        if (discordConfig.GetValue("Enable", false))
-        {
+        if (Enabled)
             Client.Initialize();
-        }
     }
 
+#nullable enable
     public void SetPresence(string details, string? state = null)
     {
+        if (!Enabled)
+            return;
+
         Client.SetPresence(new RichPresence()
         {
             Details = details,

Capy64/PluginManager/PluginLoadContext.cs

@@ -21,7 +21,7 @@ namespace Capy64.PluginManager
 {
     class PluginLoadContext : AssemblyLoadContext
     {
-        private AssemblyDependencyResolver _resolver;
+        private readonly AssemblyDependencyResolver _resolver;
 
         public PluginLoadContext(string pluginPath)
         {

Capy64/PluginManager/PluginLoader.cs

@@ -14,7 +14,6 @@
 // limitations under the License.
 
 using Capy64.API;
-using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -33,7 +32,7 @@ internal class PluginLoader
         return loadContext.LoadFromAssemblyName(new AssemblyName(Path.GetFileNameWithoutExtension(path)));
     }
 
-    public static List<IComponent> LoadAllPlugins(string pluginsPath, IServiceProvider provider)
+    public static List<IComponent> LoadAllPlugins(string pluginsPath)
     {
         if (!Directory.Exists(pluginsPath))
             Directory.CreateDirectory(pluginsPath);
@@ -47,7 +46,7 @@ internal class PluginLoader
             {
                 if (typeof(IComponent).IsAssignableFrom(type))
                 {
-                    IComponent result = ActivatorUtilities.CreateInstance(provider, type) as IComponent;
+                    IComponent result = Activator.CreateInstance(type, Capy64.Instance) as IComponent;
                     plugins.Add(result);
                 }
             }

Capy64/Program.cs

@@ -13,34 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using Capy64;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using System.IO;
-
 using var game = new Capy64.Capy64();
-using IHost host = Host.CreateDefaultBuilder(args)
-    .ConfigureAppConfiguration((context, c) =>
-    {
-        var settingsPath = Path.Combine(Capy64.Capy64.AppDataPath, "settings.json");
-        if (!Directory.Exists(Capy64.Capy64.AppDataPath))
-        {
-            Directory.CreateDirectory(Capy64.Capy64.AppDataPath);
-        }
-        if (!File.Exists(settingsPath))
-        {
-            File.Copy("Assets/default.json", settingsPath);
-        }
 
-        c.AddJsonFile("Assets/default.json", false);
-        c.AddJsonFile(settingsPath, false);
-    })
-    .ConfigureServices((hostContext, services) =>
-    {
-        services.AddSingleton<IGame>(game);
-        services.AddHostedService<Worker>();
-    })
-    .Build();
-
-await host.RunAsync();
+game.Run();

Capy64/Runtime/Constants.cs

@@ -18,4 +18,6 @@ namespace Capy64.Runtime;
 public class Constants
 {
     public const int MULTRET = -1;
+    public const int MINSTACK = 20;
+    public const int MAXLENNUM = 200;
 }

Capy64/Runtime/EventEmitter.cs

@@ -13,7 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using Capy64.Core;
 using Capy64.Eventing.Events;
 using Microsoft.Xna.Framework.Input;
 using System;
@@ -24,8 +23,8 @@ namespace Capy64.Runtime;
 
 internal class EventEmitter
 {
-    private Eventing.EventEmitter _eventEmitter;
-    private LuaState _runtime;
+    private readonly Eventing.EventEmitter _eventEmitter;
+    private readonly LuaState _runtime;
     private const int rebootDelay = 30;
     private int heldReboot = 0;
 

Capy64/Runtime/Extensions/Utils.cs

@@ -97,17 +97,4 @@ public static class Utils
         }
         return 1;
     }
-
-    [Obsolete("This method does not work as intended and requires more research")]
-    public static void PushManagedObject<T>(this Lua L, T obj)
-    {
-        var type = obj.GetType();
-        var members = type.GetMembers().Where(m => m.MemberType == MemberTypes.Method);
-        L.CreateTable(0, members.Count());
-        foreach (var m in members)
-        {
-            L.PushCFunction(L => (int)type.InvokeMember(m.Name, BindingFlags.InvokeMethod, null, obj, new object[] { L }));
-            L.SetField(-2, m.Name);
-        }
-    }
-}
+}

Capy64/Runtime/Libraries/AudioLib.cs

@@ -21,18 +21,18 @@ using static Capy64.Core.Audio;
 
 namespace Capy64.Runtime.Libraries;
 
-public class Audio : IComponent
+public class AudioLib : IComponent
 {
     private const int queueLimit = 8;
 
-    private static IGame _game;
-    public Audio(IGame game)
+    private static Capy64 _game;
+    public AudioLib(Capy64 game)
     {
         _game = game;
         _game.EventEmitter.OnClose += OnClose;
     }
 
-    private static LuaRegister[] AudioLib = new LuaRegister[]
+    private static readonly LuaRegister[] Library = new LuaRegister[]
     {
         new()
         {
@@ -85,10 +85,18 @@ public class Audio : IComponent
     private static int OpenLib(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
-        L.NewLib(AudioLib);
+        L.NewLib(Library);
         return 1;
     }
 
+    // Convert 8bit PCM to 16bit PCM
+    private static void PCMTo16bit(Span<byte> buffer, int i, byte value)
+    {
+        var value16bit = value / sbyte.MaxValue * short.MaxValue;
+        buffer[2 * i - 2] = (byte)(value16bit & 0xff);
+        buffer[2 * i - 1] = (byte)(value16bit >> 8);
+    }
+
     private static int L_Play(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
@@ -97,18 +105,24 @@ public class Audio : IComponent
 
         if (L.IsString(1))
         {
-            buffer = L.CheckBuffer(1);
+            var inputBuffer = L.CheckBuffer(1);
+            buffer = new byte[inputBuffer.Length * 2];
+            var span = new Span<byte>(buffer);
+            for (int i = 1; i < inputBuffer.Length; i++)
+            {
+                PCMTo16bit(span, i, inputBuffer[i]);
+            }
         }
         else
         {
             L.CheckType(1, LuaType.Table);
             var len = L.RawLen(1);
-            buffer = new byte[len];
+            buffer = new byte[len * 2];
+            var span = new Span<byte>(buffer);
             for (int i = 1; i <= len; i++)
             {
                 L.GetInteger(1, i);
-                var value = L.CheckInteger(-1);
-                buffer[i - 1] = (byte)value;
+                PCMTo16bit(span, i, (byte)L.CheckNumber(-1));
                 L.Pop(1);
             }
         }
@@ -133,7 +147,12 @@ public class Audio : IComponent
             L.Error(ex.Message);
         }
 
-        return 0;
+        var playTime = _game.Audio.HQChannel.GetSampleDuration(buffer.Length);
+
+        L.PushBoolean(true);
+        L.PushNumber(playTime.TotalSeconds);
+
+        return 2;
     }
 
     private static int L_Beep(IntPtr state)

Capy64/Runtime/Libraries/Event.cs

@@ -1,127 +0,0 @@
-// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
-// Copyright 2023 Alessandro "AlexDevs" Proto
-//
-// Licensed under the Apache License, Version 2.0 (the "License").
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-using Capy64.API;
-using KeraLua;
-using System;
-
-namespace Capy64.Runtime.Libraries;
-
-public class Event : IComponent
-{
-    private static IGame _game;
-    public Event(IGame game)
-    {
-        _game = game;
-    }
-
-    private static LuaRegister[] EventLib = new LuaRegister[]
-    {
-        new()
-        {
-            name = "pull",
-            function = L_Pull,
-        },
-        new()
-        {
-            name = "pullRaw",
-            function = L_PullRaw
-        },
-        new()
-        {
-            name = "push",
-            function = L_Push,
-        },
-        new(),
-    };
-
-    public void LuaInit(Lua L)
-    {
-        L.RequireF("event", OpenLib, false);
-    }
-
-    private static int OpenLib(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-        L.NewLib(EventLib);
-        return 1;
-    }
-
-    private static int LK_Pull(IntPtr state, int status, IntPtr ctx)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        if (L.ToString(1) == "interrupt")
-        {
-            L.Error("interrupt");
-        }
-
-        var nargs = L.GetTop();
-
-        return nargs;
-    }
-
-    private static int L_Pull(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        var nargs = L.GetTop();
-        for (int i = 1; i <= nargs; i++)
-        {
-            L.CheckString(i);
-        }
-
-        L.YieldK(nargs, 0, LK_Pull);
-
-        return 0;
-    }
-
-    private static int L_PullRaw(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        var nargs = L.GetTop();
-        for (int i = 1; i <= nargs; i++)
-        {
-            L.CheckString(i);
-        }
-
-        L.Yield(nargs);
-
-        return 0;
-    }
-
-    private static int L_Push(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        var eventName = L.CheckString(1);
-
-        var nargs = L.GetTop();
-        var parsState = L.NewThread();
-        L.Pop(1);
-        L.XMove(parsState, nargs - 1);
-
-        _game.LuaRuntime.QueueEvent(eventName, LK =>
-        {
-            var nargs = parsState.GetTop();
-            parsState.XMove(LK, nargs);
-
-            return nargs;
-        });
-
-        return 0;
-    }
-}

Capy64/Runtime/Libraries/EventLib.cs

@@ -0,0 +1,204 @@
+// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
+// Copyright 2023 Alessandro "AlexDevs" Proto
+//
+// Licensed under the Apache License, Version 2.0 (the "License").
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Capy64.API;
+using Capy64.Runtime.Objects;
+using KeraLua;
+using System;
+
+namespace Capy64.Runtime.Libraries;
+
+public class EventLib : IComponent
+{
+    private const int MaxPushQueue = 64;
+    private static int PushQueue = 0;
+
+    private static Lua UserQueue;
+
+    private static bool FrozenTaskAwaiter = false;
+
+    private static Capy64 _game;
+    public EventLib(Capy64 game)
+    {
+        _game = game;
+    }
+
+    private static readonly LuaRegister[] Library = new LuaRegister[]
+    {
+        new()
+        {
+            name = "push",
+            function = L_Push,
+        },
+        new()
+        {
+            name = "setAwaiter",
+            function = L_SetTaskAwaiter,
+        },
+        new()
+        {
+            name = "fulfill",
+            function = L_Fulfill,
+        },
+        new()
+        {
+            name = "reject",
+            function = L_Reject,
+        },
+        new()
+        {
+            name = "newTask",
+            function = L_NewTask,
+        },
+        new(),
+    };
+
+    public void LuaInit(Lua L)
+    {
+        PushQueue = 0;
+        UserQueue = _game.LuaRuntime.Parent.NewThread();
+
+        FrozenTaskAwaiter = false;
+
+        L.RequireF("event", OpenLib, false);
+    }
+
+    private static int OpenLib(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+        L.NewLib(Library);
+        return 1;
+    }
+
+    private static int L_Push(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var eventName = L.CheckString(1);
+
+        if (PushQueue >= MaxPushQueue)
+            L.Error("maximum event queue exceeded");
+
+        PushQueue++;
+        var nargs = L.GetTop();
+        var parsState = UserQueue.NewThread();
+        L.XMove(parsState, nargs - 1);
+
+        _game.LuaRuntime.QueueEvent(eventName, LK =>
+        {
+            PushQueue--;
+            var parsState = UserQueue.ToThread(-1);
+            var nargs = parsState.GetTop();
+            parsState.XMove(LK, nargs);
+            parsState.Close();
+            UserQueue.Pop(1);
+
+            return nargs;
+        });
+
+        return 0;
+    }
+
+    private static int L_SetTaskAwaiter(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        L.CheckType(1, LuaType.Function);
+
+        if (FrozenTaskAwaiter)
+        {
+            L.Error("awaiter is frozen");
+        }
+
+        FrozenTaskAwaiter = L.ToBoolean(2);
+
+        L.GetMetaTable(TaskMeta.ObjectType);
+        L.GetField(-1, "__index");
+
+        L.Rotate(1, -1);
+        L.SetField(-2, "await");
+        L.Pop(2);
+
+        return 0;
+    }
+
+    private static int L_Fulfill(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        L.CheckType(1, LuaType.Table);
+
+        L.GetField(1, "task");
+
+        var task = TaskMeta.CheckTask(L, -1, false);
+        L.CheckAny(2);
+        L.ArgumentCheck(!L.IsNil(2), 2, "value cannot be nil");
+
+        if (!task.UserTask)
+        {
+            L.Error("attempt to fulfill machine task");
+        }
+
+        if (task.Status != TaskMeta.TaskStatus.Running)
+        {
+            L.Error("attempt to fulfill a finished task");
+        }
+
+        task.Fulfill(lk =>
+        {
+            L.XMove(lk, 1);
+        });
+
+        return 0;
+    }
+
+    private static int L_Reject(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        L.CheckType(1, LuaType.Table);
+
+        L.GetField(1, "task");
+
+        var task = TaskMeta.CheckTask(L, -1, false);
+        var error = L.CheckString(2);
+
+        if (!task.UserTask)
+        {
+            L.Error("attempt to reject machine task");
+        }
+
+        if (task.Status != TaskMeta.TaskStatus.Running)
+        {
+            L.Error("attempt to reject a finished task");
+        }
+
+        task.Reject(error);
+
+        return 0;
+    }
+
+    private static int L_NewTask(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var name = L.OptString(1, "object");
+
+        var task = TaskMeta.Push(L, name);
+        task.UserTask = true;
+
+        return 1;
+    }
+}

Capy64/Runtime/Libraries/FileSystemLib.cs

@@ -24,11 +24,11 @@ using System.Linq;
 
 namespace Capy64.Runtime.Libraries;
 
-public class FileSystem : IComponent
+public class FileSystemLib : IComponent
 {
     public static string DataPath = Path.Combine(Capy64.AppDataPath, "data");
 
-    public FileSystem()
+    public FileSystemLib()
     {
         if (!Directory.Exists(DataPath))
         {
@@ -37,7 +37,7 @@ public class FileSystem : IComponent
     }
 
     // functions to add to the library, always end libraries with null
-    private LuaRegister[] FsLib = new LuaRegister[] {
+    private readonly LuaRegister[] Library = new LuaRegister[] {
         new()
         {
             name = "list",
@@ -111,6 +111,8 @@ public class FileSystem : IComponent
         new(), // NULL
     };
 
+    public FileSystemLib(Capy64 _) { }
+
     public void LuaInit(Lua state)
     {
         // Add "fs" library to lua, not global (uses require())
@@ -120,7 +122,7 @@ public class FileSystem : IComponent
     private int Open(IntPtr state)
     {
         var l = Lua.FromIntPtr(state);
-        l.NewLib(FsLib);
+        l.NewLib(Library);
         return 1;
     }
 
@@ -132,6 +134,9 @@ public class FileSystem : IComponent
         // Get drive root (C:\ for Windows, / for *nix)
         var rootPath = Path.GetFullPath(Path.GetPathRoot("/") ?? "/");
 
+        var invalidPathChars = Path.GetInvalidPathChars();
+        path = invalidPathChars.Aggregate(path, (current, invalidChar) => current.Replace(invalidChar, ' '));
+
         // Join path to rootPath and resolves to absolute path
         // Relative paths are resolved here (es. ../ and ./)
         var absolutePath = Path.GetFullPath(path, rootPath);
@@ -426,19 +431,26 @@ public class FileSystem : IComponent
             L.Error("path not found");
         }
 
-        var attr = File.GetAttributes(path);
-        if (attr.HasFlag(FileAttributes.Directory))
+        try
         {
-            if (!recursive && Directory.GetFileSystemEntries(path).Any())
+            var attr = File.GetAttributes(path);
+            if (attr.HasFlag(FileAttributes.Directory))
             {
-                L.Error("directory not empty");
-                return 0;
+                if (!recursive && Directory.GetFileSystemEntries(path).Any())
+                {
+                    L.Error("directory not empty");
+                    return 0;
+                }
+                Directory.Delete(path, recursive);
+            }
+            else
+            {
+                File.Delete(path);
             }
-            Directory.Delete(path, recursive);
         }
-        else
+        catch (Exception e)
         {
-            File.Delete(path);
+            return L.Error(e.Message);
         }
 
         return 0;
@@ -509,7 +521,7 @@ public class FileSystem : IComponent
         var mode = L.OptString(2, "r");
 
         var errorMessage = "invalid file mode";
-        if (mode.Length < 1 && mode.Length > 2)
+        if (mode.Length < 1)
         {
             L.ArgumentError(2, errorMessage);
             return 0;
@@ -541,26 +553,20 @@ public class FileSystem : IComponent
                 return 0;
         }
 
-        bool binaryMode = false;
-        if (mode.Length == 2)
+        try
         {
-            if (mode[1] == 'b')
-            {
-                binaryMode = true;
-            }
-            else
-            {
-                L.ArgumentError(2, errorMessage);
-                return 0;
-            }
+            var fileStream = File.Open(path, fileMode, fileAccess, FileShare.ReadWrite | FileShare.Delete);
+
+            ObjectManager.PushObject(L, fileStream);
+            L.SetMetaTable(FileHandle.ObjectType);
+
+            return 1;
         }
-
-        var fileStream = File.Open(path, fileMode, fileAccess, FileShare.ReadWrite | FileShare.Delete);
-
-        ObjectManager.PushObject(L, fileStream);
-        L.SetMetaTable(FileHandle.ObjectType);
-
-        return 1;
+        catch (Exception ex)
+        {
+            L.Error(ex.Message);
+        }
+        return 0;
     }
 
 }

Capy64/Runtime/Libraries/GPULib.cs

@@ -21,19 +21,20 @@ using Microsoft.Xna.Framework.Graphics;
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading.Tasks;
 
 namespace Capy64.Runtime.Libraries;
 
-public class GPU : IComponent
+public class GPULib : IComponent
 {
 
-    private static IGame _game;
-    public GPU(IGame game)
+    private static Capy64 _game;
+    public GPULib(Capy64 game)
     {
         _game = game;
     }
 
-    private LuaRegister[] gpuLib = new LuaRegister[] {
+    private readonly LuaRegister[] Library = new LuaRegister[] {
         new()
         {
             name = "getSize",
@@ -46,13 +47,8 @@ public class GPU : IComponent
         },
         new()
         {
-            name = "getScale",
-            function = L_GetScale,
-        },
-        new()
-        {
-            name = "setScale",
-            function = L_SetScale,
+            name = "isResizable",
+            function = L_IsResizable,
         },
         new()
         {
@@ -125,14 +121,24 @@ public class GPU : IComponent
             function = L_NewBuffer,
         },
         new()
+        {
+            name = "bufferFrom",
+            function = L_BufferFrom,
+        },
+        new()
         {
             name = "drawBuffer",
             function = L_DrawBuffer,
         },
         new()
         {
-            name = "loadImage",
-            function = L_LoadImage,
+            name = "loadImageAsync",
+            function = L_LoadImageAsync,
+        },
+        new()
+        {
+            name = "clear",
+            function = L_Clear,
         },
         new(), // NULL
     };
@@ -145,9 +151,15 @@ public class GPU : IComponent
     public int OpenLib(IntPtr state)
     {
         var l = Lua.FromIntPtr(state);
-        l.NewLib(gpuLib);
+        l.NewLib(Library);
         return 1;
     }
+
+    public static void GetColor(uint c, out byte r, out byte g, out byte b)
+    {
+        Utils.UnpackRGB(c, out r, out g, out b);
+    }
+
     private static int L_GetSize(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
@@ -162,6 +174,11 @@ public class GPU : IComponent
     {
         var L = Lua.FromIntPtr(state);
 
+        if (_game.EngineMode == EngineMode.Classic)
+        {
+            return L.Error("Screen is not resizable");
+        }
+
         var w = L.CheckInteger(1);
         var h = L.CheckInteger(2);
 
@@ -170,29 +187,18 @@ public class GPU : IComponent
 
         _game.UpdateSize();
 
-        return 0;
-    }
-
-    private static int L_GetScale(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        L.PushNumber(_game.Scale);
+        L.PushBoolean(true);
 
         return 1;
     }
 
-    private static int L_SetScale(IntPtr state)
+    private static int L_IsResizable(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
 
-        var s = L.CheckNumber(1);
+        L.PushBoolean(_game.EngineMode != EngineMode.Classic);
 
-        _game.Scale = (float)s;
-
-        _game.UpdateSize();
-
-        return 0;
+        return 1;
     }
 
     private static int L_GetPixel(IntPtr state)
@@ -217,7 +223,7 @@ public class GPU : IComponent
         var y = (int)L.CheckNumber(2) - 1;
         var c = L.CheckInteger(3);
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.Plot(new Point(x, y), new Color(r, g, b));
 
         return 0;
@@ -252,7 +258,7 @@ public class GPU : IComponent
             pts.Add(new Point(x, y));
         }
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.Plot(pts, new(r, g, b));
 
         return 0;
@@ -267,7 +273,7 @@ public class GPU : IComponent
         var c = L.CheckInteger(3);
         var s = (int)L.OptNumber(4, 1);
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.DrawPoint(new(x, y), new Color(r, g, b), s);
 
         return 0;
@@ -284,7 +290,7 @@ public class GPU : IComponent
         var t = (int)L.OptNumber(5, 1);
         var s = (int)L.OptInteger(6, -1);
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.DrawCircle(new(x, y), rad, new Color(r, g, b), t, s);
 
         return 0;
@@ -294,14 +300,14 @@ public class GPU : IComponent
     {
         var L = Lua.FromIntPtr(state);
 
-        var x1 = (int)L.CheckNumber(1);
+        var x1 = (int)L.CheckNumber(1) - 1; // do not question, please
         var y1 = (int)L.CheckNumber(2);
         var x2 = (int)L.CheckNumber(3);
         var y2 = (int)L.CheckNumber(4);
         var c = L.CheckInteger(5);
         var s = (int)L.OptNumber(6, 1);
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.DrawLine(new(x1, y1), new(x2, y2), new Color(r, g, b), s);
 
         return 0;
@@ -318,7 +324,7 @@ public class GPU : IComponent
         var c = L.CheckInteger(5);
         var s = (int)L.OptNumber(6, 1);
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.DrawRectangle(new(x, y), new(w, h), new Color(r, g, b), s);
 
         return 0;
@@ -354,7 +360,7 @@ public class GPU : IComponent
             pts.Add(new(xp, yp));
         }
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.DrawPolygon(new(x, y), pts.ToArray(), new(r, g, b), s);
 
         return 0;
@@ -371,7 +377,7 @@ public class GPU : IComponent
         var c = L.CheckInteger(5);
         var s = (int)L.OptNumber(6, 1);
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         _game.Drawing.DrawEllipse(new(x, y), new(rx, ry), new Color(r, g, b), s);
 
         return 0;
@@ -386,7 +392,7 @@ public class GPU : IComponent
         var c = L.CheckInteger(3);
         var t = L.CheckString(4);
 
-        Utils.UnpackRGB((uint)c, out var r, out var g, out var b);
+        GetColor((uint)c, out var r, out var g, out var b);
         try
         {
             _game.Drawing.DrawString(new Vector2(x, y), t, new Color(r, g, b));
@@ -417,12 +423,19 @@ public class GPU : IComponent
     {
         var L = Lua.FromIntPtr(state);
 
+
         var buffer = new uint[_game.Width * _game.Height];
         _game.Drawing.Canvas.GetData(buffer);
 
-        ObjectManager.PushObject(L, buffer);
-        //L.PushObject(buffer);
-        L.SetMetaTable(GPUBuffer.ObjectType);
+        var gpuBuffer = new GPUBufferMeta.GPUBuffer
+        {
+            Buffer = buffer,
+            Width = _game.Width,
+            Height = _game.Height,
+        };
+
+        ObjectManager.PushObject(L, gpuBuffer);
+        L.SetMetaTable(GPUBufferMeta.ObjectType);
 
         return 1;
     }
@@ -431,9 +444,9 @@ public class GPU : IComponent
     {
         var L = Lua.FromIntPtr(state);
 
-        var buffer = GPUBuffer.CheckBuffer(L, false);
+        var buffer = GPUBufferMeta.CheckBuffer(L, false);
 
-        _game.Drawing.Canvas.SetData(buffer);
+        _game.Drawing.Canvas.SetData(buffer.Buffer);
 
         return 0;
     }
@@ -442,13 +455,71 @@ public class GPU : IComponent
     {
         var L = Lua.FromIntPtr(state);
 
-        var width = L.OptInteger(1, _game.Width);
-        var height = L.OptInteger(2, _game.Height);
+        var width = (int)L.OptInteger(1, _game.Width);
+        var height = (int)L.OptInteger(2, _game.Height);
 
         var buffer = new uint[width * height];
 
-        ObjectManager.PushObject(L, buffer);
-        L.SetMetaTable(GPUBuffer.ObjectType);
+        var gpuBuffer = new GPUBufferMeta.GPUBuffer
+        {
+            Buffer = buffer,
+            Width = width,
+            Height = height,
+        };
+
+        ObjectManager.PushObject(L, gpuBuffer);
+        L.SetMetaTable(GPUBufferMeta.ObjectType);
+
+        return 1;
+    }
+
+    private static int L_BufferFrom(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        L.CheckType(1, LuaType.Table);
+        var width = (int)L.CheckInteger(2);
+        var height = (int)L.CheckInteger(3);
+
+        if (width <= 0)
+        {
+            return L.ArgumentError(2, "width must be a positive integer.");
+        }
+
+        if (height <= 0)
+        {
+            return L.ArgumentError(3, "height must be a positive integer.");
+        }
+
+        var buffer = new uint[width * height];
+
+        var tableSize = L.RawLen(1);
+        L.ArgumentCheck(tableSize == buffer.Length, 1, "table length does not match buffer size");
+
+        for (int i = 1; i <= tableSize; i++)
+        {
+            L.GetInteger(1, i);
+            var value = (uint)L.CheckInteger(-1);
+            L.Pop(1);
+            // ARGB to ABGR
+            value =
+                (value & 0xFF_00_00_00U) |
+                ((value & 0x00_FF_00_00U) >> 16) | // move R
+                (value & 0x00_00_FF_00U) |       // move G
+                ((value & 0x00_00_00_FFU) << 16); // move B
+
+            buffer[i - 1] = value;
+        }
+
+        var gpuBuffer = new GPUBufferMeta.GPUBuffer
+        {
+            Buffer = buffer,
+            Width = width,
+            Height = height,
+        };
+
+        ObjectManager.PushObject(L, gpuBuffer);
+        L.SetMetaTable(GPUBufferMeta.ObjectType);
 
         return 1;
     }
@@ -457,36 +528,123 @@ public class GPU : IComponent
     {
         var L = Lua.FromIntPtr(state);
 
-        var buffer = GPUBuffer.CheckBuffer(L, false);
+        var buffer = GPUBufferMeta.CheckBuffer(L, false);
 
         var x = (int)L.CheckInteger(2) - 1;
         var y = (int)L.CheckInteger(3) - 1;
-        var w = (int)L.CheckInteger(4);
-        var h = (int)L.CheckInteger(5);
 
-        if (w * h != buffer.Length)
+        Rectangle? source = null;
+        Color color = Color.White;
+        float rotation = 0;
+        Vector2 origin = Vector2.Zero;
+        Vector2 scale = Vector2.One;
+        SpriteEffects effects = SpriteEffects.None;
+
+        if (L.IsTable(4))
         {
-            L.Error("width and height do not match buffer size");
+            if (L.GetField(-1, "source") == LuaType.Table)
+            {
+                int sx, sy, sw, sh;
+
+                if (L.GetInteger(-1, 1) != LuaType.Number)
+                    L.CheckNumber(-1);
+                sx = (int)L.ToNumber(-1);
+                L.Pop(1);
+
+                if (L.GetInteger(-1, 2) != LuaType.Number)
+                    L.CheckNumber(-1);
+                sy = (int)L.ToNumber(-1);
+                L.Pop(1);
+
+                if (L.GetInteger(-1, 3) != LuaType.Number)
+                    L.CheckNumber(-1);
+                sw = (int)L.ToNumber(-1);
+                L.Pop(1);
+
+                if (L.GetInteger(-1, 4) != LuaType.Number)
+                    L.CheckNumber(-1);
+                sh = (int)L.ToNumber(-1);
+                L.Pop(1);
+
+                source = new(sx, sy, sw, sh);
+            }
+            L.Pop(1);
+
+            if (L.GetField(-1, "color") == LuaType.Number)
+            {
+                var c = (uint)L.ToNumber(-1);
+                GetColor(c, out var r, out var g, out var b);
+                color = new Color(r, g, b);
+            }
+            L.Pop(1);
+
+            if (L.GetField(-1, "rotation") == LuaType.Number)
+            {
+                rotation = (float)L.ToNumber(-1);
+            }
+            L.Pop(1);
+
+            if (L.GetField(-1, "origin") == LuaType.Table)
+            {
+                int ox, oy;
+
+                if (L.GetInteger(-1, 1) != LuaType.Number)
+                    L.CheckNumber(-1);
+                ox = (int)L.ToNumber(-1);
+                L.Pop(1);
+
+                if (L.GetInteger(-1, 2) != LuaType.Number)
+                    L.CheckNumber(-1);
+                oy = (int)L.ToNumber(-1);
+                L.Pop(1);
+
+                origin = new Vector2(ox, oy);
+            }
+            L.Pop(1);
+
+            if (L.GetField(-1, "scale") == LuaType.Table)
+            {
+                float sx = 1;
+                float sy = 1;
+
+                if (L.GetInteger(-1, 1) == LuaType.Number)
+                    sx = (float)L.ToNumber(-1);
+                L.Pop(1);
+
+                if (L.GetInteger(-1, 2) == LuaType.Number)
+                    sy = (float)L.ToNumber(-1);
+                L.Pop(1);
+
+                scale = new(sx, sy);
+            }
+            L.Pop(1);
+
+            if (L.GetField(-1, "effects") == LuaType.Number)
+            {
+                var flags = L.CheckInteger(-1);
+                effects = (SpriteEffects)flags;
+            }
+            L.Pop(1);
         }
 
-        _game.Drawing.DrawBuffer(buffer, new()
+        _game.Drawing.DrawBuffer(buffer.Buffer, new()
         {
             X = x,
             Y = y,
-            Width = w,
-            Height = h,
-        });
+            Width = buffer.Width,
+            Height = buffer.Height,
+        }, source, color, rotation, origin, scale, effects);
 
         return 0;
     }
 
-    private static int L_LoadImage(IntPtr state)
+    private static int L_LoadImageAsync(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
 
         var path = L.CheckString(1);
 
-        path = FileSystem.Resolve(path);
+        path = FileSystemLib.Resolve(path);
 
         if (!File.Exists(path))
         {
@@ -494,6 +652,8 @@ public class GPU : IComponent
             return 0;
         }
 
+        var task = TaskMeta.Push(L, GPUBufferMeta.ObjectType);
+
         Texture2D texture;
         try
         {
@@ -501,20 +661,68 @@ public class GPU : IComponent
         }
         catch (Exception e)
         {
-            L.Error(e.Message);
-            return 0;
+            task.Reject(e.Message);
+            return 1;
         }
 
         var data = new uint[texture.Width * texture.Height];
         texture.GetData(data);
 
-        ObjectManager.PushObject(L, data);
-        L.SetMetaTable(GPUBuffer.ObjectType);
-        L.PushInteger(texture.Width);
-        L.PushInteger(texture.Height);
+        Task.Run(() =>
+        {
+            /*if (_game.EngineMode == EngineMode.Classic)
+            {
+                for (int i = 0; i < data.Length; i++)
+                {
+                    var value = data[i];
 
-        texture.Dispose();
+                    // ABGR to RGB
+                    value =
+                        ((value & 0x00_00_00_FFU) << 16) | // move R
+                        (value & 0x00_00_FF_00U) |       // move G
+                        ((value & 0x00_FF_00_00U) >> 16);  // move B
 
-        return 3;
+                    value = ColorPalette.GetColor(value);
+
+                    // RGB to ABGR
+                    value =
+                        ((value & 0x00_FF_00_00U) >> 16) | // move R
+                        (value & 0x00_00_FF_00U) |       // move G
+                        ((value & 0x00_00_00_FFU) << 16) | // move B
+                        0xFF_00_00_00U;
+
+                    data[i] = value;
+                }
+            }*/
+
+            var buffer = new GPUBufferMeta.GPUBuffer
+            {
+                Buffer = data,
+                Height = texture.Height,
+                Width = texture.Width,
+            };
+
+            task.Fulfill(lk =>
+            {
+                ObjectManager.PushObject(lk, buffer);
+                lk.SetMetaTable(GPUBufferMeta.ObjectType);
+            });
+
+            texture.Dispose();
+        });
+
+        return 1;
+    }
+
+    private static int L_Clear(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var c = L.OptInteger(1, 0x000000);
+
+        GetColor((uint)c, out var r, out var g, out var b);
+        _game.Drawing.Clear(new Color(r, g, b));
+
+        return 0;
     }
 }

Capy64/Runtime/Libraries/HTTPLib.cs

@@ -28,17 +28,17 @@ using System.Threading;
 
 namespace Capy64.Runtime.Libraries;
 #nullable enable
-public class HTTP : IComponent
+public class HTTPLib : IComponent
 {
-    private static IGame _game;
-    private static HttpClient _httpClient;
+    private static Capy64 _game = null!;
+    private static HttpClient _httpClient = null!;
     private static long _requestId;
     public static readonly HashSet<WebSocketClient.Client> WebSocketConnections = new();
 
     public static readonly string UserAgent = $"Capy64/{Capy64.Version}";
 
-    private static IConfiguration _configuration;
-    private readonly LuaRegister[] HttpLib = new LuaRegister[]
+    private static IConfiguration _configuration = null!;
+    private readonly LuaRegister[] Library = new LuaRegister[]
     {
         new()
         {
@@ -57,13 +57,13 @@ public class HTTP : IComponent
         },
         new(),
     };
-    public HTTP(IGame game, IConfiguration configuration)
+    public HTTPLib(Capy64 game)
     {
         _game = game;
         _requestId = 0;
         _httpClient = new();
         _httpClient.DefaultRequestHeaders.Add("User-Agent", UserAgent);
-        _configuration = configuration;
+        _configuration = game.Configuration;
     }
 
     public void LuaInit(Lua L)
@@ -75,7 +75,7 @@ public class HTTP : IComponent
     private int Open(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
-        L.NewLib(HttpLib);
+        L.NewLib(Library);
         return 1;
     }
 
@@ -170,7 +170,7 @@ public class HTTP : IComponent
                         options["method"] = L.CheckString(-2);
                         break;
                     case "binary":
-                        options["binary"] = L.IsBoolean(-2) ? L.ToBoolean(-2) : false;
+                        options["binary"] = L.ToBoolean(-2);
                         break;
                 }
 
@@ -198,19 +198,15 @@ public class HTTP : IComponent
 
         var requestId = _requestId++;
 
+        var luaTask = TaskMeta.Push(L, "HTTPRequest");
+
         var reqTask = _httpClient.SendAsync(request);
         reqTask.ContinueWith(async (task) =>
         {
 
             if (task.IsFaulted || task.IsCanceled)
             {
-                _game.LuaRuntime.QueueEvent("http_failure", LK =>
-                {
-                    LK.PushInteger(requestId);
-                    LK.PushString(task.Exception?.Message);
-
-                    return 2;
-                });
+                luaTask.Reject(task.Exception?.Message);
                 return;
             }
 
@@ -218,23 +214,15 @@ public class HTTP : IComponent
 
             var stream = await response.Content.ReadAsStreamAsync();
 
-            _game.LuaRuntime.QueueEvent("http_response", LK =>
+            luaTask.Fulfill(LK =>
             {
-                // arg 1, request id
-                LK.PushInteger(requestId);
-
-                // arg 2, response data
-                ObjectManager.PushObject(L, stream);
-                //L.PushObject(stream);
-                L.SetMetaTable(FileHandle.ObjectType);
-                /*if ((bool)options["binary"])
-                    BinaryReadHandle.Push(LK, new(stream));
-                else
-                    ReadHandle.Push(LK, new(stream));*/
-
-                // arg 3, response info
                 LK.NewTable();
 
+                LK.PushString("content");
+                ObjectManager.PushObject(LK, stream);
+                LK.SetMetaTable(FileHandle.ObjectType);
+                LK.SetTable(-3);
+
                 LK.PushString("success");
                 LK.PushBoolean(response.IsSuccessStatusCode);
                 LK.SetTable(-3);
@@ -258,15 +246,9 @@ public class HTTP : IComponent
                 }
 
                 LK.SetTable(-3);
-
-                return 3;
-
             });
-
         });
 
-        L.PushInteger(requestId);
-
         return 1;
     }
 
@@ -332,19 +314,14 @@ public class HTTP : IComponent
             L.Pop(1);
         }
 
+        var clientTask = TaskMeta.Push(L, WebSocketClient.ObjectType);
 
         var connectTask = wsClient.ConnectAsync(uri, CancellationToken.None);
         connectTask.ContinueWith(async task =>
         {
             if (task.IsFaulted || task.IsCanceled)
             {
-                _game.LuaRuntime.QueueEvent("websocket_failure", LK =>
-                {
-                    LK.PushInteger(requestId);
-                    LK.PushString(task.Exception?.Message);
-
-                    return 2;
-                });
+                clientTask.Reject(task.Exception?.Message);
                 return;
             }
 
@@ -353,14 +330,10 @@ public class HTTP : IComponent
             var handle = new WebSocketClient.Client(wsClient, requestId);
             WebSocketConnections.Add(handle);
 
-            _game.LuaRuntime.QueueEvent("websocket_connect", LK =>
+            clientTask.Fulfill(LK =>
             {
-                LK.PushInteger(requestId);
-
                 ObjectManager.PushObject(LK, handle);
                 LK.SetMetaTable(WebSocketClient.ObjectType);
-
-                return 2;
             });
 
             var buffer = new byte[4096];

Capy64/Runtime/Libraries/MachineLib.cs

@@ -22,15 +22,15 @@ using System;
 
 namespace Capy64.Runtime.Libraries;
 
-public class Machine : IComponent
+public class MachineLib : IComponent
 {
-    private static IGame _game;
-    public Machine(IGame game)
+    private static Capy64 _game;
+    public MachineLib(Capy64 game)
     {
         _game = game;
     }
 
-    private static LuaRegister[] MachineLib = new LuaRegister[]
+    private static readonly LuaRegister[] Library = new LuaRegister[]
     {
         new()
         {
@@ -83,7 +83,7 @@ public class Machine : IComponent
     private static int OpenLib(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
-        L.NewLib(MachineLib);
+        L.NewLib(Library);
         return 1;
     }
 
@@ -94,10 +94,14 @@ public class Machine : IComponent
         return 0;
     }
 
-    private static int L_Reboot(IntPtr _)
+    private static int L_Reboot(IntPtr state)
     {
+        var L = Lua.FromIntPtr(state);
+
         RuntimeManager.Reboot();
 
+        L.Yield(0);
+
         return 0;
     }
 

Capy64/Runtime/Libraries/TermLib.cs

@@ -23,7 +23,7 @@ using static Capy64.Utils;
 
 namespace Capy64.Runtime.Libraries;
 
-internal class Term : IComponent
+internal class TermLib : IComponent
 {
     private struct Char
     {
@@ -49,11 +49,11 @@ internal class Term : IComponent
     public static Color BackgroundColor { get; set; }
     private static Char?[] CharGrid;
 
-    private static IGame _game;
+    private static Capy64 _game;
     private static bool cursorState = false;
     private static bool enableCursor = true;
     private static Texture2D cursorTexture;
-    public Term(IGame game)
+    public TermLib(Capy64 game)
     {
         _game = game;
 
@@ -72,7 +72,7 @@ internal class Term : IComponent
         _game.EventEmitter.OnScreenSizeChange += OnScreenSizeChange;
     }
 
-    private LuaRegister[] TermLib = new LuaRegister[]
+    private readonly LuaRegister[] Library = new LuaRegister[]
     {
         new()
         {
@@ -99,6 +99,10 @@ internal class Term : IComponent
             name = "setSize",
             function = L_SetSize,
         },
+        new() {
+            name = "isResizable",
+            function = L_IsResizable,
+        },
         new()
         {
             name = "getForeground",
@@ -170,10 +174,17 @@ internal class Term : IComponent
     public int Open(IntPtr state)
     {
         var l = Lua.FromIntPtr(state);
-        l.NewLib(TermLib);
+        l.NewLib(Library);
         return 1;
     }
 
+    public static void GetColor(uint c, out byte r, out byte g, out byte b)
+    {
+        /*if (_game.EngineMode == EngineMode.Classic)
+            c = ColorPalette.GetColor(c);*/
+        UnpackRGB(c, out r, out g, out b);
+    }
+
     public static void UpdateSize(bool resize = true)
     {
         Array.Resize(ref CharGrid, Width * Height);
@@ -209,12 +220,12 @@ internal class Term : IComponent
             _game.Drawing.DrawString(charpos, ch.ToString(), fg);
 
         }
-        catch (ArgumentException ex) // UTF-16 fuckery
+        catch (ArgumentException) // UTF-16 fuckery
         {
             _game.Drawing.DrawString(charpos, "\xFFFD", fg);
         }
 
-        if(underline)
+        if (underline)
         {
             _game.Drawing.DrawLine(charpos + new Vector2(0, CharHeight), charpos + new Vector2(CharWidth, CharHeight), fg);
         }
@@ -305,7 +316,8 @@ internal class Term : IComponent
         if (cursorState)
         {
             var realpos = ToRealPos(CursorPosition - Vector2.One);
-            var charpos = (realpos * _game.Scale) + (CharOffset + new Vector2(0, 2)) * _game.Scale;
+            var charpos = (realpos * _game.Scale) + ((CharOffset + new Vector2(0, 2)) * _game.Scale);
+            charpos += new Vector2(Capy64.Instance.Borders.Left, Capy64.Instance.Borders.Top);
             _game.Game.SpriteBatch.Draw(cursorTexture, charpos, null, ForegroundColor, 0f, Vector2.Zero, _game.Scale, SpriteEffects.None, 0);
         }
     }
@@ -387,6 +399,11 @@ internal class Term : IComponent
     {
         var L = Lua.FromIntPtr(state);
 
+        if (_game.EngineMode == EngineMode.Classic)
+        {
+            return L.Error("Terminal is not resizable");
+        }
+
         var w = (int)L.CheckNumber(1);
         var h = (int)L.CheckNumber(2);
 
@@ -401,7 +418,17 @@ internal class Term : IComponent
 
         SetSize(w, h);
 
-        return 0;
+        L.PushBoolean(true);
+        return 1;
+    }
+
+    private static int L_IsResizable(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        L.PushBoolean(_game.EngineMode != EngineMode.Classic);
+
+        return 1;
     }
 
     private static int L_GetForegroundColor(IntPtr state)
@@ -426,12 +453,14 @@ internal class Term : IComponent
             r = (byte)L.CheckNumber(1);
             g = (byte)L.CheckNumber(2);
             b = (byte)L.CheckNumber(3);
+            //UnpackRGB(ColorPalette.GetColor(r, g, b), out r, out g, out b);
+
         }
         // packed RGB value
         else if (argsn == 1)
         {
             var c = (uint)L.CheckInteger(1);
-            UnpackRGB(c, out r, out g, out b);
+            GetColor(c, out r, out g, out b);
         }
         else
         {
@@ -466,12 +495,13 @@ internal class Term : IComponent
             r = (byte)L.CheckNumber(1);
             g = (byte)L.CheckNumber(2);
             b = (byte)L.CheckNumber(3);
+            //UnpackRGB(ColorPalette.GetColor(r, g, b), out r, out g, out b);
         }
         // packed RGB value
         else if (argsn == 1)
         {
             var c = (uint)L.CheckInteger(1);
-            UnpackRGB(c, out r, out g, out b);
+            GetColor(c, out r, out g, out b);
         }
         else
         {
@@ -519,8 +549,6 @@ internal class Term : IComponent
 
     private static int L_Clear(IntPtr state)
     {
-        var L = Lua.FromIntPtr(state);
-
         Clear();
 
         return 0;
@@ -534,8 +562,6 @@ internal class Term : IComponent
 
     private static int L_ClearLine(IntPtr state)
     {
-        var L = Lua.FromIntPtr(state);
-
         ClearLine();
 
         return 0;

Capy64/Runtime/Libraries/Timer.cs

@@ -1,114 +0,0 @@
-// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
-// Copyright 2023 Alessandro "AlexDevs" Proto
-//
-// Licensed under the Apache License, Version 2.0 (the "License").
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-using Capy64.API;
-using KeraLua;
-using System;
-using System.Collections.Concurrent;
-
-namespace Capy64.Runtime.Libraries;
-
-class Timer : IComponent
-{
-    private LuaRegister[] TimerLib = new LuaRegister[]
-    {
-        new()
-        {
-            name = "start",
-            function = L_StartTimer,
-        },
-        new()
-        {
-            name = "now",
-            function = L_Now
-        },
-
-        new(),
-    };
-
-    private static IGame _game;
-    private static uint _timerId = 0;
-
-    private static ConcurrentDictionary<uint, System.Timers.Timer> timers = new();
-    public Timer(IGame game)
-    {
-        _game = game;
-    }
-
-    public void LuaInit(Lua state)
-    {
-        _timerId = 0;
-
-        foreach (var pair in timers)
-        {
-            pair.Value.Stop();
-            pair.Value.Dispose();
-        }
-
-        timers.Clear();
-
-        state.RequireF("timer", Open, false);
-    }
-
-    private int Open(IntPtr state)
-    {
-        var l = Lua.FromIntPtr(state);
-        l.NewLib(TimerLib);
-        return 1;
-    }
-
-    private static int L_StartTimer(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        var delay = L.CheckNumber(1);
-        L.ArgumentCheck(delay > 0, 1, "delay must be greater than 0");
-
-        var timerId = _timerId++;
-        var timer = new System.Timers.Timer
-        {
-            AutoReset = false,
-            Enabled = true,
-            Interval = delay,
-        };
-
-        timers[timerId] = timer;
-
-        timer.Elapsed += (o, e) =>
-        {
-            timers.TryRemove(timerId, out _);
-
-            _game.LuaRuntime.QueueEvent("timer", LK =>
-            {
-                LK.PushInteger(timerId);
-
-                return 1;
-            });
-        };
-
-        L.PushInteger(timerId);
-        return 1;
-    }
-
-    private static int L_Now(IntPtr state)
-    {
-        var now = DateTimeOffset.UtcNow;
-        var L = Lua.FromIntPtr(state);
-
-        L.PushInteger(now.ToUnixTimeMilliseconds());
-
-        return 1;
-    }
-}

Capy64/Runtime/Libraries/TimerLib.cs

@@ -0,0 +1,160 @@
+// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
+// Copyright 2023 Alessandro "AlexDevs" Proto
+//
+// Licensed under the Apache License, Version 2.0 (the "License").
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Capy64.API;
+using Capy64.Runtime.Objects;
+using KeraLua;
+using System;
+using System.Collections.Concurrent;
+
+namespace Capy64.Runtime.Libraries;
+
+class TimerLib : IComponent
+{
+    public class Timer
+    {
+        public int RemainingTicks = 0;
+        public TaskMeta.RuntimeTask Task = null!;
+    }
+
+    private readonly LuaRegister[] Library = new LuaRegister[]
+    {
+        new()
+        {
+            name = "start",
+            function = L_StartTimer,
+        },
+        new()
+        {
+            name = "delay",
+            function = L_Delay,
+        },
+        new()
+        {
+            name = "now",
+            function = L_Now
+        },
+
+        new(),
+    };
+
+    private static Capy64 _game;
+    private static uint _timerId = 0;
+
+    private static readonly ConcurrentDictionary<uint, Timer> timers = new();
+    public TimerLib(Capy64 game)
+    {
+        _game = game;
+
+        _game.EventEmitter.OnTick += OnTick;
+    }
+
+    private void OnTick(object sender, Eventing.Events.TickEvent e)
+    {
+        if (e.IsActiveTick)
+        {
+            foreach (var t in timers)
+            {
+                var timer = t.Value;
+                timer.RemainingTicks--;
+                if (timer.RemainingTicks <= 0)
+                {
+                    if (timer.Task == null)
+                    {
+                        _game.LuaRuntime.QueueEvent("timer", lk =>
+                        {
+                            lk.PushInteger(t.Key);
+
+                            return 1;
+                        });
+                    }
+                    else
+                    {
+                        timer.Task.Fulfill(lk =>
+                        {
+                            lk.PushInteger(t.Key);
+                        });
+                    }
+
+                    timers.TryRemove(t.Key, out _);
+                }
+            }
+        }
+    }
+
+    public void LuaInit(Lua state)
+    {
+        _timerId = 0;
+
+        timers.Clear();
+
+        state.RequireF("timer", Open, false);
+    }
+
+    private int Open(IntPtr state)
+    {
+        var l = Lua.FromIntPtr(state);
+        l.NewLib(Library);
+        return 1;
+    }
+
+
+
+    private static int L_StartTimer(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var delay = L.CheckNumber(1);
+
+        var timerId = _timerId++;
+
+        timers[timerId] = new Timer
+        {
+            RemainingTicks = (int)(delay * Capy64.Instance.TickRate)
+        };
+
+        L.PushInteger(timerId);
+        return 1;
+    }
+
+    private static int L_Delay(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var delay = L.CheckNumber(1);
+
+        var task = TaskMeta.Push(L, "timer");
+
+        var timerId = _timerId++;
+
+        timers[timerId] = new Timer
+        {
+            RemainingTicks = (int)(delay * Capy64.Instance.TickRate),
+            Task = task,
+        };
+
+        return 1;
+    }
+
+    private static int L_Now(IntPtr state)
+    {
+        var now = DateTimeOffset.UtcNow;
+        var L = Lua.FromIntPtr(state);
+
+        L.PushInteger(now.ToUnixTimeMilliseconds());
+
+        return 1;
+    }
+}

Capy64/Runtime/LuaState.cs

@@ -26,7 +26,7 @@ namespace Capy64.Runtime;
 public class LuaState : IDisposable
 {
     public Lua Thread;
-    private readonly Lua _parent;
+    public readonly Lua Parent;
 
     private readonly ConcurrentQueue<LuaEvent> _queue = new();
 
@@ -36,25 +36,21 @@ public class LuaState : IDisposable
 
     public LuaState()
     {
-        _parent = new Lua(false)
+        Parent = new Lua(false)
         {
             Encoding = Encoding.UTF8,
         };
 
-        Sandbox.OpenLibraries(_parent);
-        Sandbox.Patch(_parent);
+        Sandbox.OpenLibraries(Parent);
+        Sandbox.Patch(Parent);
 
-        Thread = _parent.NewThread();
+        Thread = Parent.NewThread();
 
         Thread.SetHook(LH_YieldTimeout, LuaHookMask.Count, 7000);
         yieldTimeoutTimer.Elapsed += (sender, ev) =>
         {
             yieldTimedOut = true;
         };
-
-        InitPlugins();
-
-        Thread.SetTop(0);
     }
 
     private static void LH_YieldTimeout(IntPtr state, IntPtr ar)
@@ -64,10 +60,16 @@ public class LuaState : IDisposable
         if (yieldTimedOut)
         {
             L.Error("no yield timeout");
-            Console.WriteLine("tick");
         }
     }
 
+    public void Init()
+    {
+        InitPlugins();
+
+        Thread.SetTop(0);
+    }
+
     private void InitPlugins()
     {
         var allPlugins = new List<IComponent>(Capy64.Instance.NativePlugins);
@@ -192,6 +194,6 @@ public class LuaState : IDisposable
         GC.SuppressFinalize(this);
         _queue.Clear();
         Thread.Close();
-        _parent.Close();
+        Parent.Close();
     }
 }

Capy64/Runtime/ObjectManager.cs

@@ -23,25 +23,39 @@ namespace Capy64.Runtime;
 
 public class ObjectManager : IComponent
 {
-    private static ConcurrentDictionary<nint, object> _objects = new();
+    private static readonly ConcurrentDictionary<nint, object> _objects = new();
 
-    private static IGame _game;
-    public ObjectManager(IGame game)
+    private static Capy64 _game;
+    public ObjectManager(Capy64 game)
     {
         _game = game;
         _game.EventEmitter.OnClose += OnClose;
     }
 
-    public static void PushObject<T>(Lua L, T obj)
+    public static nint PushObject<T>(Lua L, T obj)
     {
         if (obj == null)
         {
             L.PushNil();
-            return;
+            return nint.Zero;
         }
 
         var p = L.NewUserData(1);
         _objects[p] = obj;
+        return p;
+    }
+
+    public static T GetObject<T>(nint address, bool freeGCHandle = false)
+    {
+        if (!_objects.ContainsKey(address))
+            return default(T);
+
+        var reference = (T)_objects[address];
+
+        if (freeGCHandle)
+            _objects.Remove(address, out _);
+
+        return reference;
     }
 
     public static T ToObject<T>(Lua L, int index, bool freeGCHandle = true)

Capy64/Runtime/Objects/FileHandle.cs

@@ -16,7 +16,11 @@
 using Capy64.API;
 using KeraLua;
 using System;
+using System.Diagnostics;
 using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using static Capy64.Runtime.Constants;
 
 namespace Capy64.Runtime.Objects;
 
@@ -24,7 +28,7 @@ public class FileHandle : IComponent
 {
     public const string ObjectType = "file";
 
-    private static LuaRegister[] Methods = new LuaRegister[]
+    private static readonly LuaRegister[] Methods = new LuaRegister[]
     {
         new()
         {
@@ -59,7 +63,7 @@ public class FileHandle : IComponent
         new(),
     };
 
-    private static LuaRegister[] MetaMethods = new LuaRegister[]
+    private static readonly LuaRegister[] MetaMethods = new LuaRegister[]
     {
         new()
         {
@@ -84,6 +88,8 @@ public class FileHandle : IComponent
         new(),
     };
 
+    public FileHandle(Capy64 _) { }
+
     public void LuaInit(Lua L)
     {
         CreateMeta(L);
@@ -133,7 +139,16 @@ public class FileHandle : IComponent
 
     private static bool ReadNumber(Lua L, Stream stream)
     {
-        return false;
+        var str = ReadHelper.ReadNumber(stream);
+        if (L.StringToNumber(str))
+        {
+            return true;
+        }
+        else
+        {
+            L.PushNil();
+            return false;
+        }
     }
 
     private static bool ReadLine(Lua L, Stream stream, bool chop)
@@ -187,40 +202,57 @@ public class FileHandle : IComponent
             return 2;
         }
 
-        var nargs = L.GetTop() - 1;
-        if (nargs == 0)
-        {
-            L.PushString("l");
-        }
+        return G_Read(L, stream, 2);
+    }
 
+    private static int G_Read(Lua L, Stream f, int first)
+    {
+        var nargs = L.GetTop() - 1;
+        int n;
         bool success;
-        if (L.Type(2) == LuaType.Number)
+
+        if (nargs == 0) // no arguments?
         {
-            success = ReadChars(L, stream, (int)L.ToNumber(2));
+            success = ReadLine(L, f, true);
+            n = first + 1; // to return 1 result
         }
         else
         {
-            var p = L.CheckString(2);
-            var mode = CheckMode(p);
-            switch (mode)
+            // ensure stack space for all results and for auxlib's buffer
+            L.CheckStack(nargs + MINSTACK, "too many arguments");
+            success = true;
+            for (n = first; (nargs-- > 0) && success; n++)
             {
-                case 'n':
-                    success = ReadNumber(L, stream);
-                    break;
-                case 'l':
-                    success = ReadLine(L, stream, true);
-                    break;
-                case 'L':
-                    success = ReadLine(L, stream, false);
-                    break;
-                case 'a':
-                    ReadAll(L, stream);
-                    success = true;
-                    break;
-                default:
-                    return L.ArgumentError(2, "invalid format");
-            }
+                if (L.Type(n) == LuaType.Number)
+                {
+                    var l = (int)L.CheckInteger(n);
+                    success = (l == 0) ? f.Position == f.Length : ReadChars(L, f, l);
+                }
+                else
+                {
+                    var p = L.CheckString(n);
+                    var mode = CheckMode(p);
+                    switch (mode)
+                    {
+                        case 'n': // number
+                            success = ReadNumber(L, f);
+                            break;
+                        case 'l': // line
+                            success = ReadLine(L, f, true);
+                            break;
+                        case 'L': // line with end-of-line
+                            success = ReadLine(L, f, false);
+                            break;
+                        case 'a': // file
+                            ReadAll(L, f); // read entire file
+                            success = true; // always success
+                            break;
+                        default:
+                            return L.ArgumentError(n, "invalid format");
+                    }
 
+                }
+            }
         }
 
         if (!success)
@@ -229,7 +261,7 @@ public class FileHandle : IComponent
             L.PushNil();
         }
 
-        return 1;
+        return n - first;
     }
 
     private static int L_Write(IntPtr state)
@@ -264,7 +296,6 @@ public class FileHandle : IComponent
 
     private static int L_Lines(IntPtr state)
     {
-        return 0;
         var L = Lua.FromIntPtr(state);
         var maxargn = 250;
 
@@ -275,11 +306,51 @@ public class FileHandle : IComponent
         L.PushInteger(n);
         L.PushBoolean(false);
         L.Rotate(2, 3);
-        L.PushCClosure(null, 3 + n); // todo
+        L.PushCClosure(IO_ReadLine, 3 + n);
 
         return 1;
     }
 
+    private static int IO_ReadLine(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+        var stream = ObjectManager.ToObject<Stream>(L, Lua.UpValueIndex(1), false);
+        int i;
+        int n = (int)L.ToInteger(Lua.UpValueIndex(2));
+        if (stream is null)
+        {
+            return L.Error("file is already closed");
+        }
+        L.SetTop(1);
+        L.CheckStack(n, "too many arguments");
+        for (i = 1; i <= n; i++)
+        {
+            L.PushCopy(Lua.UpValueIndex(3 + i));
+        }
+        n = G_Read(L, stream, 2);
+        Debug.Assert(n > 0);
+        if (L.ToBoolean(-n))
+        {
+            return n;
+        }
+        else
+        {
+            if (n > 1)
+            {
+                return L.Error(L.ToString(-n + 1));
+            }
+            if (L.ToBoolean(Lua.UpValueIndex(3)))
+            {
+                L.SetTop(0);
+                L.PushCopy(Lua.UpValueIndex(1));
+                stream.Close();
+            }
+        }
+
+
+        return 0;
+    }
+
     private static int L_Flush(IntPtr state)
     {
         var L = Lua.FromIntPtr(state);
@@ -344,9 +415,124 @@ public class FileHandle : IComponent
         var L = Lua.FromIntPtr(state);
 
         var stream = ToStream(L, true);
-        if (stream is not null)
-            stream.Close();
+        stream?.Close();
 
         return 0;
     }
+
+    private static class ReadHelper
+    {
+        static bool isdigit(char c)
+        {
+            return "0123456789"
+                .Contains(c, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        static bool isxdigit(char c)
+        {
+            return "0123456789abcdef"
+                .Contains(c, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        static bool isspace(char c)
+        {
+            return new char[] {
+                ' ',
+                '\n',
+                '\t',
+                '\v',
+                '\f',
+                '\r',
+            }.Contains(c);
+        }
+
+        static bool test_eof(Lua L, Stream f)
+        {
+            L.PushString("");
+            return f.Position != f.Length;
+        }
+
+        static bool nextc(RN rn)
+        {
+            if (rn.n >= 200) // buffer overflow?
+            {
+                rn.buff[0] = '\0'; // invalidate result
+                return false; // fail
+            }
+            else
+            {
+                rn.buff[rn.n] = rn.c; // save current char
+                rn.n++;
+                rn.c = (char)rn.f.ReadByte(); // read next one
+                return true;
+            }
+        }
+
+        static bool test2(RN rn, string set)
+        {
+            if (rn.c == set[0] || rn.c == set[1])
+            {
+                return nextc(rn);
+            }
+            return false;
+        }
+
+        static int readdigits(RN rn, bool hex)
+        {
+            int count = 0;
+            while ((hex ? isxdigit(rn.c) : isdigit(rn.c)) && nextc(rn))
+                count++;
+            return count;
+        }
+
+
+        /// <summary>
+        /// https://www.lua.org/source/5.4/liolib.c.html#read_number
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <returns></returns>
+        public static string ReadNumber(Stream stream)
+        {
+            RN rn = new()
+            {
+                buff = new char[201]
+            };
+
+            int count = 0;
+            bool hex = false;
+            string decp = "..";
+            rn.f = stream;
+            rn.n = 0;
+
+            do
+            {
+                rn.c = (char)rn.f.ReadByte();
+            } while (isspace(rn.c)); /* skip spaces */
+
+            test2(rn, "+-"); /* optional sign */
+            if (test2(rn, "00"))
+            {
+                if (test2(rn, "xX")) hex = true; /* numeral is hexadecimal */
+                else count = 1; /* count initial '0' as a valid digit */
+            }
+            count += readdigits(rn, hex); // integral part
+            if (test2(rn, decp))  // decimal point?
+                count += readdigits(rn, hex);  // fractional part
+            if (count > 0 && test2(rn, (hex ? "pP" : "eE")))
+            {  /* exponent mark? */
+                test2(rn, "-+");  /* exponent sign */
+                readdigits(rn, false);  /* exponent digits */
+            }
+            rn.f.Position += -1;
+            return new string(rn.buff);
+        }
+
+        public class RN
+        {
+            public Stream f;
+            public char c;
+            public int n;
+            public char[] buff;
+        }
+    }
 }

Capy64/Runtime/Objects/GPUBufferMeta.cs

@@ -19,11 +19,18 @@ using System;
 
 namespace Capy64.Runtime.Objects;
 
-public class GPUBuffer : IComponent
+public class GPUBufferMeta : IComponent
 {
     public const string ObjectType = "GPUBuffer";
 
-    private static LuaRegister[] MetaMethods = new LuaRegister[]
+    public struct GPUBuffer
+    {
+        public uint[] Buffer { get; set; }
+        public int Width { get; set; }
+        public int Height { get; set; }
+    }
+
+    private static readonly LuaRegister[] MetaMethods = new LuaRegister[]
     {
         new()
         {
@@ -59,29 +66,43 @@ public class GPUBuffer : IComponent
         new(),
     };
 
+    private static Capy64 _game;
+    public GPUBufferMeta(Capy64 game)
+    {
+        _game = game;
+    }
+
     public void LuaInit(Lua L)
     {
         CreateMeta(L);
     }
 
+    public static uint GetColor(uint color)
+    {
+        /*if (_game.EngineMode == EngineMode.Classic)
+            return ColorPalette.GetColor(color);*/
+
+        return color;
+    }
+
     public static void CreateMeta(Lua L)
     {
         L.NewMetaTable(ObjectType);
         L.SetFuncs(MetaMethods, 0);
     }
 
-    public static uint[] ToBuffer(Lua L, bool gc = false)
+    public static GPUBuffer ToBuffer(Lua L, bool gc = false)
     {
-        return ObjectManager.ToObject<uint[]>(L, 1, gc);
+        return ObjectManager.ToObject<GPUBuffer>(L, 1, gc);
     }
 
-    public static uint[] CheckBuffer(Lua L, bool gc = false)
+    public static GPUBuffer CheckBuffer(Lua L, bool gc = false)
     {
-        var obj = ObjectManager.CheckObject<uint[]>(L, 1, ObjectType, gc);
-        if (obj is null)
+        var obj = ObjectManager.CheckObject<GPUBuffer>(L, 1, ObjectType, gc);
+        if (obj.Buffer is null)
         {
             L.Error("attempt to use a closed buffer");
-            return null;
+            return default;
         }
         return obj;
     }
@@ -94,22 +115,31 @@ public class GPUBuffer : IComponent
 
         if (!L.IsInteger(2))
         {
-            L.PushNil();
+            var vkey = L.ToString(2);
+
+            if (vkey == "width")
+                L.PushInteger(buffer.Width);
+            else if (vkey == "height")
+                L.PushInteger(buffer.Height);
+            else
+                L.PushNil();
+
             return 1;
         }
 
         var key = L.ToInteger(2);
 
-        if (key < 0 || key >= buffer.Length)
+        if (key < 0 || key >= buffer.Buffer.Length)
         {
             L.PushNil();
             return 1;
         }
 
-        var value = buffer[key];
+        var value = buffer.Buffer[key];
 
-        // ABGR to RGB
+        // ABGR to ARGB
         value =
+            (value & 0xFF_00_00_00U) |
             ((value & 0x00_00_00_FFU) << 16) | // move R
             (value & 0x00_00_FF_00U) |       // move G
             ((value & 0x00_FF_00_00U) >> 16);  // move B
@@ -131,7 +161,7 @@ public class GPUBuffer : IComponent
 
         var key = L.ToInteger(2);
 
-        if (key < 0 || key >= buffer.Length)
+        if (key < 0 || key >= buffer.Buffer.Length)
         {
             return 0;
         }
@@ -142,16 +172,16 @@ public class GPUBuffer : IComponent
         }
 
         var value = (uint)L.ToInteger(3);
+        value = GetColor(value);
 
-        // RGB to ABGR
+        // ARGB to ABGR
         value =
+            (value & 0xFF_00_00_00U) |
             ((value & 0x00_FF_00_00U) >> 16) | // move R
             (value & 0x00_00_FF_00U) |       // move G
-            ((value & 0x00_00_00_FFU) << 16) | // move B
-            0xFF_00_00_00U;
+            ((value & 0x00_00_00_FFU) << 16); // move B
 
-
-        buffer[key] = value;
+        buffer.Buffer[key] = value;
 
         return 0;
     }
@@ -171,7 +201,7 @@ public class GPUBuffer : IComponent
 
         var buffer = CheckBuffer(L, false);
 
-        L.PushInteger(buffer.LongLength);
+        L.PushInteger(buffer.Buffer.LongLength);
 
         return 1;
     }
@@ -180,7 +210,7 @@ public class GPUBuffer : IComponent
     {
         var L = Lua.FromIntPtr(state);
         var buffer = ToBuffer(L);
-        if (buffer is not null)
+        if (buffer.Buffer is not null)
         {
             L.PushString("GPUBuffer ({0:X})", (ulong)&buffer);
         }

Capy64/Runtime/Objects/Socket.cs

@@ -0,0 +1,55 @@
+// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
+// Copyright 2023 Alessandro "AlexDevs" Proto
+//
+// Licensed under the Apache License, Version 2.0 (the "License").
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Capy64.API;
+using KeraLua;
+using System;
+
+namespace Capy64.Runtime.Objects;
+
+public class Socket : IDisposable
+{
+    public void Dispose()
+    {
+        GC.SuppressFinalize(this);
+    }
+}
+
+public class SocketLib : IComponent
+{
+    private static Capy64 _game = null!;
+    public SocketLib(Capy64 game)
+    {
+        _game = game;
+    }
+
+    private static readonly LuaRegister[] Methods = new LuaRegister[] {
+
+        new(),
+    };
+
+    private static readonly LuaRegister[] MetaMethods = new LuaRegister[] {
+        new()
+        {
+            name = "__index",
+        },
+        new(),
+    };
+
+    public void LuaInit(Lua L)
+    {
+
+    }
+}

Capy64/Runtime/Objects/Task.cs

@@ -0,0 +1,448 @@
+// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
+// Copyright 2023 Alessandro "AlexDevs" Proto
+//
+// Licensed under the Apache License, Version 2.0 (the "License").
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Capy64.API;
+using KeraLua;
+using System;
+
+namespace Capy64.Runtime.Objects;
+
+public class TaskMeta : IComponent
+{
+    private static Capy64 _game;
+    public TaskMeta(Capy64 game)
+    {
+        _game = game;
+    }
+
+    public const string ObjectType = "Task";
+
+    public enum TaskStatus
+    {
+        Running,
+        Succeeded,
+        Failed,
+    }
+    public class RuntimeTask
+    {
+        public RuntimeTask(string name = "object")
+        {
+            Name = name;
+        }
+
+        public Guid Guid { get; set; } = Guid.NewGuid();
+        public nint Pointer { get; set; } = nint.Zero;
+        public string Name { get; set; }
+        public TaskStatus Status { get; set; } = TaskStatus.Running;
+        public string Error { get; private set; }
+        public int DataIndex { get; private set; } = 0;
+        public bool UserTask { get; set; } = false;
+
+        /// <summary>
+        /// Pops one element at the top of the container (lk) stack and uses it as task value.
+        /// 
+        /// The container must contain a value and cannot be nil.
+        /// </summary>
+        /// <param name="lk"></param>
+        /// <exception cref="Exception">Throws if the value nil or the stack is empty</exception>
+        public void Fulfill(Action<Lua> lk)
+        {
+            Status = TaskStatus.Succeeded;
+
+            var container = tasks.NewThread();
+            lk(container);
+            if (container.IsNoneOrNil(-1))
+            {
+                throw new Exception("Task result cannot be nil");
+            }
+            container.XMove(tasks, 1);
+            tasks.Remove(-2);
+            var emptySpot = FindSpot();
+            if (emptySpot > -1)
+            {
+                tasks.Replace(emptySpot);
+                DataIndex = emptySpot;
+            }
+            else
+            {
+                DataIndex = tasks.GetTop();
+            }
+
+            _game.LuaRuntime.QueueEvent("task_finish", LK =>
+            {
+                LK.PushString(Guid.ToString());
+
+                tasks.PushCopy(DataIndex);
+                tasks.XMove(LK, 1);
+
+                LK.PushNil();
+
+                return 3;
+            });
+        }
+
+        /// <summary>
+        /// Rejects the task with an error message.
+        /// </summary>
+        /// <param name="error"></param>
+        /// <param name="args"></param>
+        public void Reject(string error, params object[] args)
+        {
+            Status = TaskStatus.Failed;
+            Error = string.Format(error, args);
+
+            _game.LuaRuntime.QueueEvent("task_finish", LK =>
+            {
+                LK.PushString(Guid.ToString());
+
+                LK.PushNil();
+
+                LK.PushString(Error);
+
+                return 3;
+            });
+        }
+    }
+
+    private static readonly LuaRegister[] Methods = new LuaRegister[]
+    {
+        new()
+        {
+            name = "await",
+            function = L_Await,
+        },
+        new()
+        {
+            name = "getID",
+            function = L_GetID,
+        },
+        new()
+        {
+            name = "getType",
+            function = L_GetType,
+        },
+        new()
+        {
+            name = "getStatus",
+            function = L_GetStatus,
+        },
+        new()
+        {
+            name = "getResult",
+            function = L_GetResult,
+        },
+        new()
+        {
+            name = "getError",
+            function = L_GetError,
+        },
+        new(),
+    };
+
+    private static readonly LuaRegister[] MetaMethods = new LuaRegister[]
+    {
+        new()
+        {
+            name = "__index",
+        },
+        new()
+        {
+            name = "__gc",
+            function = LM_GC,
+        },
+        new()
+        {
+            name = "__close",
+            function = LM_GC,
+        },
+        new()
+        {
+            name = "__tostring",
+            function = LM_ToString,
+        },
+
+        new(),
+    };
+
+    private static Lua tasks;
+    public void LuaInit(Lua L)
+    {
+        tasks = _game.LuaRuntime.Parent.NewThread();
+
+        CreateMeta(L);
+    }
+
+    public static void CreateMeta(Lua L)
+    {
+        L.NewMetaTable(ObjectType);
+        L.SetFuncs(MetaMethods, 0);
+        L.NewLibTable(Methods);
+        L.SetFuncs(Methods, 0);
+        L.SetField(-2, "__index");
+        L.Pop(1);
+    }
+
+    public static RuntimeTask Push(Lua L, string typeName)
+    {
+        if (!tasks.CheckStack(1))
+        {
+            L.Error("tasks limit exceeded");
+        }
+
+        var task = new RuntimeTask(typeName);
+
+        L.NewTable();
+        task.Pointer = ObjectManager.PushObject(L, task);
+        L.SetMetaTable(ObjectType);
+        L.SetField(-2, "task");
+
+        L.SetMetaTable(ObjectType);
+
+        return task;
+    }
+
+    public static RuntimeTask ToTask(Lua L, int index = 1, bool gc = false)
+    {
+        RuntimeTask task;
+        if (L.Type(index) != LuaType.Table)
+        {
+            if (L.TestUserData(index, ObjectType) == nint.Zero)
+            {
+                return null;
+            }
+            else
+            {
+                task = ObjectManager.ToObject<RuntimeTask>(L, index, gc);
+
+            }
+        }
+        else
+        {
+            L.GetField(index, "task");
+            task = task = ObjectManager.ToObject<RuntimeTask>(L, -1, gc);
+        }
+        return task;
+    }
+
+    public static RuntimeTask CheckTask(Lua L, int index = 1, bool gc = false)
+    {
+        RuntimeTask task;
+        if (L.Type(index) != LuaType.Table)
+        {
+            task = ObjectManager.CheckObject<RuntimeTask>(L, index, ObjectType, gc);
+        }
+        else
+        {
+            L.GetField(index, "task");
+            task = ObjectManager.CheckObject<RuntimeTask>(L, -1, ObjectType, gc);
+        }
+
+        if (task is null)
+        {
+            L.Error("attempt to use a closed task");
+            return null;
+        }
+        return task;
+    }
+
+    private static int FindSpot()
+    {
+        var top = tasks.GetTop();
+        for (int i = 1; i <= top; i++)
+        {
+            if (tasks.IsNil(i))
+                return i;
+        }
+
+        return -1;
+    }
+
+    private static void GCTasks()
+    {
+        var top = tasks.GetTop();
+        int peak = 0;
+        for (int i = top; i > 0; i--)
+        {
+            if (!tasks.IsNil(i))
+            {
+                peak = i;
+                break;
+            }
+        }
+
+        tasks.SetTop(peak);
+    }
+
+    private static void WaitForTask(Lua L)
+    {
+        L.PushString("coroutine");
+        L.GetTable(-1);
+        L.GetField(-1, "yield");
+        L.PushString("task_finish");
+        L.CallK(1, 4, 0, LK_Await);
+    }
+
+    private static int L_Await(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        L.Warning("Native task awaiter should be avoided", false);
+
+        var task = CheckTask(L, 1, false);
+
+        if (task.Status == TaskStatus.Succeeded)
+        {
+            // Push copy of value on top and move it to L
+            tasks.PushCopy(task.DataIndex);
+            tasks.XMove(L, 1);
+
+            L.PushNil();
+        }
+        else if (task.Status == TaskStatus.Failed)
+        {
+            L.PushNil();
+            L.PushString(task.Error);
+        }
+        else if (task.Status == TaskStatus.Running)
+        {
+            WaitForTask(L);
+            return 0;
+        }
+
+        return 2;
+    }
+
+    private static int LK_Await(IntPtr state, int status, nint ctx)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var task = CheckTask(L, 1, false);
+
+        var taskId = L.CheckString(3);
+
+        if (task.Guid.ToString() != taskId)
+        {
+            WaitForTask(L);
+            return 0;
+        }
+
+        return 2;
+    }
+
+    private static int L_GetID(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var task = CheckTask(L, 1, false);
+
+        L.PushString(task.Guid.ToString());
+
+        return 1;
+    }
+
+    private static int L_GetType(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var task = CheckTask(L, 1, false);
+
+        L.PushString(task.Name);
+
+        return 1;
+    }
+
+    private static int L_GetStatus(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var task = CheckTask(L, 1, false);
+
+        L.PushString(task.Status.ToString().ToLower());
+
+        return 1;
+    }
+
+    private static int L_GetResult(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var task = CheckTask(L, 1, false);
+
+        if (task.Status == TaskStatus.Succeeded)
+        {
+            // Push copy of value on top and move it to L
+            tasks.PushCopy(task.DataIndex);
+            tasks.XMove(L, 1);
+        }
+        else
+        {
+            L.PushNil();
+        }
+
+        return 1;
+    }
+
+    private static int L_GetError(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var task = CheckTask(L, 1, false);
+
+        if (task.Status == TaskStatus.Failed)
+        {
+            L.PushString(task.Error);
+        }
+        else
+        {
+            L.PushNil();
+        }
+
+        return 1;
+    }
+
+    private static int LM_GC(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        L.CheckType(1, LuaType.Table);
+
+        L.GetField(1, "task");
+
+        var task = CheckTask(L, -1, true);
+        if (task is null)
+            return 0;
+
+        if (task.DataIndex >= 0)
+        {
+            tasks.PushNil();
+            tasks.Replace(task.DataIndex);
+        }
+
+        GCTasks();
+
+        return 0;
+    }
+
+    private static int LM_ToString(IntPtr state)
+    {
+        var L = Lua.FromIntPtr(state);
+
+        var task = ToTask(L);
+
+        L.PushString("Task<{0}>: {1} ({2})", task?.Name, task?.Guid, task?.Status);
+
+        return 1;
+    }
+}

Capy64/Runtime/Objects/WebSocketClient.cs

@@ -17,7 +17,6 @@ using Capy64.API;
 using Capy64.Runtime.Libraries;
 using KeraLua;
 using System;
-using System.Collections.Generic;
 using System.Net.WebSockets;
 using System.Threading;
 
@@ -29,21 +28,6 @@ public class WebSocketClient : IComponent
 
     public record Client(ClientWebSocket Socket, long RequestId);
 
-    public void LuaInit(Lua L)
-    {
-        CreateMeta(L);
-    }
-
-    public static void CreateMeta(Lua L)
-    {
-        L.NewMetaTable(ObjectType);
-        L.SetFuncs(MetaMethods, 0);
-        L.NewLibTable(Methods);
-        L.SetFuncs(Methods, 0);
-        L.SetField(-2, "__index");
-        L.Pop(1);
-    }
-
     internal static LuaRegister[] Methods = new LuaRegister[]
     {
         new()
@@ -89,12 +73,22 @@ public class WebSocketClient : IComponent
         new(),
     };
 
-    private static readonly Dictionary<string, LuaFunction> functions = new()
+    public WebSocketClient(Capy64 _) { }
+
+    public void LuaInit(Lua L)
     {
-        ["getRequestID"] = L_GetRequestId,
-        ["send"] = L_Send,
-        ["closeAsync"] = L_CloseAsync,
-    };
+        CreateMeta(L);
+    }
+
+    public static void CreateMeta(Lua L)
+    {
+        L.NewMetaTable(ObjectType);
+        L.SetFuncs(MetaMethods, 0);
+        L.NewLibTable(Methods);
+        L.SetFuncs(Methods, 0);
+        L.SetField(-2, "__index");
+        L.Pop(1);
+    }
 
     public static Client ToObject(Lua L, bool gc = false)
     {
@@ -160,7 +154,7 @@ public class WebSocketClient : IComponent
                 });
             });
 
-        HTTP.WebSocketConnections.Remove(client);
+        HTTPLib.WebSocketConnections.Remove(client);
 
         return 0;
     }
@@ -171,11 +165,11 @@ public class WebSocketClient : IComponent
         var buffer = ToObject(L);
         if (buffer is not null)
         {
-            L.PushString("GPUBuffer ({0:X})", (ulong)&buffer);
+            L.PushString("WebSocket ({0:X})", (ulong)&buffer);
         }
         else
         {
-            L.PushString("GPUBuffer (closed)");
+            L.PushString("WebSocket (closed)");
         }
         return 1;
     }

Capy64/Runtime/PanicScreen.cs

@@ -21,33 +21,33 @@ namespace Capy64.Runtime;
 public class PanicScreen
 {
     public static Color ForegroundColor = Color.White;
-    public static Color BackgroundColor = new Color(0, 51, 187);
+    public static Color BackgroundColor = new(0, 51, 187);
 
     public static void Render(string error, string details = null)
     {
-        Term.ForegroundColor = ForegroundColor;
-        Term.BackgroundColor = BackgroundColor;
-        Term.SetCursorBlink(false);
-        Term.SetSize(51, 19);
-        Term.Clear();
+        TermLib.ForegroundColor = ForegroundColor;
+        TermLib.BackgroundColor = BackgroundColor;
+        TermLib.SetCursorBlink(false);
+        TermLib.SetSize(57, 23);
+        TermLib.Clear();
 
         var title = " Capy64 ";
-        var halfX = (Term.Width / 2) + 1;
-        Term.SetCursorPosition(halfX - (title.Length / 2), 2);
-        Term.ForegroundColor = BackgroundColor;
-        Term.BackgroundColor = ForegroundColor;
-        Term.Write(title);
+        var halfX = (TermLib.Width / 2) + 1;
+        TermLib.SetCursorPosition(halfX - (title.Length / 2), 2);
+        TermLib.ForegroundColor = BackgroundColor;
+        TermLib.BackgroundColor = ForegroundColor;
+        TermLib.Write(title);
 
-        Term.ForegroundColor = ForegroundColor;
-        Term.BackgroundColor = BackgroundColor;
-        Term.SetCursorPosition(1, 4);
+        TermLib.ForegroundColor = ForegroundColor;
+        TermLib.BackgroundColor = BackgroundColor;
+        TermLib.SetCursorPosition(1, 4);
         Print(error + '\n');
 
         if (details is not null)
         {
             Print(details);
         }
-        Term.SetCursorPosition(1, 19);
+        TermLib.SetCursorPosition(1, 23);
         Print("Hold CTRL + ALT + INSERT to reboot.");
     }
 
@@ -55,12 +55,12 @@ public class PanicScreen
     {
         foreach (var ch in txt)
         {
-            Term.Write(ch.ToString());
-            if (Term.CursorPosition.X >= Term.Width || ch == '\n')
+            TermLib.Write(ch.ToString());
+            if (TermLib.CursorPosition.X >= TermLib.Width || ch == '\n')
             {
-                Term.SetCursorPosition(1, (int)Term.CursorPosition.Y + 1);
+                TermLib.SetCursorPosition(1, (int)TermLib.CursorPosition.Y + 1);
             }
         }
-        Term.SetCursorPosition(1, (int)Term.CursorPosition.Y + 1);
+        TermLib.SetCursorPosition(1, (int)TermLib.CursorPosition.Y + 1);
     }
 }

Capy64/Runtime/RuntimeManager.cs

@@ -15,7 +15,6 @@
 
 using Capy64.API;
 using Capy64.Eventing.Events;
-using Capy64.Extensions;
 using Capy64.Runtime.Libraries;
 using KeraLua;
 using System;
@@ -33,8 +32,8 @@ internal class RuntimeManager : IComponent
     private static bool close = false;
     private static bool inPanic = false;
 
-    private static IGame _game;
-    public RuntimeManager(IGame game)
+    private static Capy64 _game;
+    public RuntimeManager(Capy64 game)
     {
         _game = game;
 
@@ -98,8 +97,11 @@ internal class RuntimeManager : IComponent
     {
         _game.Discord.SetPresence("Booting up...");
 
+        InstallOS(false);
+
         luaState = new LuaState();
         _game.LuaRuntime = luaState;
+        luaState.Init();
 
         emitter = new(_game.EventEmitter, luaState);
 
@@ -111,25 +113,18 @@ internal class RuntimeManager : IComponent
 
         emitter.Register();
 
+        LoadFirmware();
+
         luaState.Thread.PushCFunction(L_OpenDataFolder);
         luaState.Thread.SetGlobal("openDataFolder");
 
-        luaState.Thread.PushCFunction(L_ShouldInstallOS);
-        luaState.Thread.SetGlobal("shouldInstallOS");
-
-        luaState.Thread.PushCFunction(L_FlagInstalled);
-        luaState.Thread.SetGlobal("flagInstalled");
+        luaState.Thread.PushCFunction(L_InstallOS);
+        luaState.Thread.SetGlobal("installOS");
 
         luaState.Thread.PushCFunction(L_Exit);
         luaState.Thread.SetGlobal("exit");
 
-        luaState.Thread.PushCFunction(L_SetConsole);
-        luaState.Thread.SetGlobal("setConsole");
-
-        luaState.Thread.PushCFunction(L_GetConsole);
-        luaState.Thread.SetGlobal("getConsole");
-
-        var status = luaState.Thread.LoadFile("Assets/bios.lua");
+        var status = luaState.Thread.LoadFile(Path.Combine(Capy64.AssetsPath, "Lua/bios.lua"));
         if (status != LuaStatus.OK)
         {
             throw new LuaException(luaState.Thread.ToString(-1));
@@ -138,10 +133,10 @@ internal class RuntimeManager : IComponent
 
     private void InitOS()
     {
-        _game.Discord.SetPresence("On CapyOS");
-
         luaState = new LuaState();
         _game.LuaRuntime = luaState;
+        luaState.Init();
+        CopyHostLibraries();
 
         emitter = new(_game.EventEmitter, luaState);
 
@@ -153,7 +148,14 @@ internal class RuntimeManager : IComponent
 
         emitter.Register();
 
-        var initContent = File.ReadAllText(Path.Combine(FileSystem.DataPath, "init.lua"));
+        LoadFirmware();
+
+        if (!File.Exists(Path.Combine(FileSystemLib.DataPath, "init.lua")))
+        {
+            throw new LuaException("Operating System not found\nMissing init.lua");
+        }
+
+        var initContent = File.ReadAllText(Path.Combine(FileSystemLib.DataPath, "init.lua"));
         var status = luaState.Thread.LoadString(initContent, "=init.lua");
         if (status != LuaStatus.OK)
         {
@@ -161,6 +163,36 @@ internal class RuntimeManager : IComponent
         }
     }
 
+    private void CopyHostLibraries()
+    {
+        // table that will contain host libraries
+        luaState.Thread.NewTable();
+
+        luaState.Thread.GetGlobal("package");
+        luaState.Thread.GetField(-1, "loaded");
+
+        luaState.Thread.PushNil();
+        while (luaState.Thread.Next(-2))
+        {
+            var libname = luaState.Thread.ToString(-2);
+            luaState.Thread.SetField(1, libname);
+        }
+
+        luaState.Thread.Rotate(1, -1);
+        luaState.Thread.SetField(1, "_host");
+        luaState.Thread.SetTop(0);
+    }
+
+    private void LoadFirmware()
+    {
+        var firmwareContent = File.ReadAllText(Path.Combine(Capy64.AssetsPath, "Lua/firmware.lua"));
+        var errored = luaState.Thread.DoString(firmwareContent);
+        if (errored)
+        {
+            throw new LuaException(luaState.Thread.ToString(-1));
+        }
+    }
+
     public static void Reset()
     {
         close = true;
@@ -178,9 +210,19 @@ internal class RuntimeManager : IComponent
         _game.Exit();
     }
 
+    public static void InstallOS(bool force = false)
+    {
+        var installedFilePath = Path.Combine(Capy64.AppDataPath, ".installed");
+        if (!File.Exists(installedFilePath) || force)
+        {
+            FileSystemLib.CopyDirectory(Path.Combine(Capy64.AssetsPath, "Lua/CapyOS"), FileSystemLib.DataPath, true, true);
+            File.Create(installedFilePath).Dispose();
+        }
+    }
+
     private static int L_OpenDataFolder(IntPtr state)
     {
-        var path = FileSystem.DataPath;
+        var path = FileSystemLib.DataPath;
         switch (Environment.OSVersion.Platform)
         {
             case PlatformID.Win32NT:
@@ -194,22 +236,9 @@ internal class RuntimeManager : IComponent
         return 0;
     }
 
-    private static int L_ShouldInstallOS(IntPtr state)
+    private static int L_InstallOS(IntPtr state)
     {
-        var L = Lua.FromIntPtr(state);
-        var installedFilePath = Path.Combine(Capy64.AppDataPath, ".installed");
-
-        L.PushBoolean(!File.Exists(installedFilePath));
-
-        return 1;
-    }
-
-    private static int L_FlagInstalled(IntPtr state)
-    {
-        var installedFilePath = Path.Combine(Capy64.AppDataPath, ".installed");
-        if (!File.Exists(installedFilePath))
-            File.Create(installedFilePath).Dispose();
-
+        InstallOS(true);
         return 0;
     }
 
@@ -219,26 +248,6 @@ internal class RuntimeManager : IComponent
         return 0;
     }
 
-    private static int L_SetConsole(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        var status = L.ToBoolean(1);
-        _game.Window.ToggleConsole(status);
-
-        return 0;
-    }
-
-    private static int L_GetConsole(IntPtr state)
-    {
-        var L = Lua.FromIntPtr(state);
-
-        var status = _game.Window.IsConsoleVisible();
-        L.PushBoolean(status);
-
-        return 1;
-    }
-
     private void OnInit(object sender, EventArgs e)
     {
         Start();
@@ -246,6 +255,7 @@ internal class RuntimeManager : IComponent
 
     private void OnTick(object sender, TickEvent e)
     {
-        Resume();
+        if (e.IsActiveTick)
+            Resume();
     }
 }

Capy64/Runtime/Sandbox.cs

@@ -121,6 +121,20 @@ internal class Sandbox
         L.SetTable(-3);
 
         L.Pop(1);
+
+        // Replace debug.debug with a dummy function to avoid stalling the program
+        L.GetGlobal("debug");
+
+        L.PushString("debug");
+        L.PushCFunction(L_Dummy);
+        L.SetTable(-3);
+
+        L.Pop(1);
+    }
+    
+    internal static int L_Dummy(IntPtr state)
+    {
+        return 0;
     }
 
     internal static int L_Searcher(IntPtr state)
@@ -192,7 +206,7 @@ internal class Sandbox
         var errorMessage = new StringBuilder();
         foreach (var possiblePath in possiblePaths)
         {
-            var path = FileSystem.Resolve(possiblePath);
+            var path = FileSystemLib.Resolve(possiblePath);
             var info = new FileInfo(path);
             if (!info.Exists)
             {
@@ -229,7 +243,7 @@ internal class Sandbox
         bool hasMode = !L.IsNone(2);
         bool hasEnv = !L.IsNone(3);
 
-        var path = FileSystem.Resolve(filename);
+        var path = FileSystemLib.Resolve(filename);
 
         var fileInfo = new FileInfo(path);
         if (!fileInfo.Exists)

Capy64/Worker.cs

@@ -1,73 +0,0 @@
-// This file is part of Capy64 - https://github.com/Ale32bit/Capy64
-// Copyright 2023 Alessandro "AlexDevs" Proto
-//
-// Licensed under the Apache License, Version 2.0 (the "License").
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-using Microsoft.Extensions.Hosting;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Capy64;
-
-public class Worker : IHostedService
-{
-    private readonly IGame _game;
-    private readonly IHostApplicationLifetime _appLifetime;
-    private readonly IServiceProvider _serviceProvider;
-
-    public Worker(IGame game, IHostApplicationLifetime appLifetime, IServiceProvider serviceProvider)
-    {
-        _game = game;
-        _appLifetime = appLifetime;
-        _serviceProvider = serviceProvider;
-    }
-
-    public Task StartAsync(CancellationToken cancellationToken)
-    {
-        _appLifetime.ApplicationStarted.Register(OnStarted);
-        _appLifetime.ApplicationStopping.Register(OnStopping);
-        _appLifetime.ApplicationStopped.Register(OnStopped);
-
-        _game.Exiting += OnGameExiting;
-
-        _game.ConfigureServices(_serviceProvider);
-
-        return Task.CompletedTask;
-    }
-
-    private void OnGameExiting(object sender, EventArgs e)
-    {
-        StopAsync(new CancellationToken());
-    }
-
-    public Task StopAsync(CancellationToken cancellationToken)
-    {
-        _appLifetime.StopApplication();
-
-        return Task.CompletedTask;
-    }
-
-    private void OnStarted()
-    {
-        _game.Run();
-    }
-
-    private void OnStopping()
-    {
-    }
-
-    private void OnStopped()
-    {
-    }
-}

ExamplePlugin/ExamplePlugin.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFramework>net7.0</TargetFramework>
+		<TargetFramework>net8.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
 		<EnableDynamicLoading>true</EnableDynamicLoading>