runtime-images.yml

shared_installs:
  node24:
    apt:
      - curl
      - xz-utils
    script:
      - export NODE_VERSION=24.15.0
      - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-x64.tar.xz" -o /tmp/node.tar.xz
      - rm -rf "/opt/node-v${NODE_VERSION}-linux-x64"
      - mkdir -p /opt
      - tar -xJf /tmp/node.tar.xz -C /opt
      - ln -sfn "/opt/node-v${NODE_VERSION}-linux-x64/bin/node" /usr/local/bin/node
      - ln -sfn "/opt/node-v${NODE_VERSION}-linux-x64/bin/node" /usr/local/bin/nodejs
      - ln -sfn "/opt/node-v${NODE_VERSION}-linux-x64/bin/npm" /usr/local/bin/npm
      - ln -sfn "/opt/node-v${NODE_VERSION}-linux-x64/bin/npx" /usr/local/bin/npx
      - rm -f /tmp/node.tar.xz

  libobjc16:
    script:
      - apt-get update -o APT::Get::List-Cleanup=false && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends -t sid libobjc-16-dev && find /var/lib/apt/lists -mindepth 1 -delete

  freebasic:
    apt:
      - curl
      - gcc
      - g++
      - libc6-dev
      - libncurses-dev
    script:
      - export FREEBASIC_VERSION=1.10.1
      - echo 'deb http://deb.debian.org/debian bullseye main' > /etc/apt/sources.list.d/aonohako-freebasic-bullseye.list
      - apt-get update -o APT::Get::List-Cleanup=false
      - DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends libtinfo5
      - rm -f /etc/apt/sources.list.d/aonohako-freebasic-bullseye.list
      - rm -f /var/lib/apt/lists/deb.debian.org_debian_dists_bullseye_*
      - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://downloads.sourceforge.net/project/fbc/FreeBASIC-${FREEBASIC_VERSION}/Binaries-Linux/FreeBASIC-${FREEBASIC_VERSION}-linux-x86_64.tar.gz" -o /tmp/freebasic.tar.gz
      - rm -rf /opt/freebasic
      - mkdir -p /opt/freebasic
      - tar -xzf /tmp/freebasic.tar.gz -C /opt/freebasic --strip-components=1
      - printf '%s\n' '#!/usr/bin/env bash' 'exec /opt/freebasic/bin/fbc "$@"' > /usr/local/bin/fbc
      - chmod 0755 /usr/local/bin/fbc
      - rm -f /tmp/freebasic.tar.gz

  gforth:
    script:
      - echo 'deb http://deb.debian.org/debian sid main' > /etc/apt/sources.list.d/aonohako-gforth-sid.list
      - apt-get update -o APT::Get::List-Cleanup=false
      - DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends -t sid gforth
      - find /var/lib/apt/lists -mindepth 1 -delete

languages:
  plain:
    install:
      apt:
        - gcc
        - g++
        - libc6-dev
        - make
    smoke:
      command:
        - /bin/sh
        - -c
        - |
          printf '%s\n' '#include <stdio.h>' 'int main(void) {' '  puts("ok");' '  return 0;' '}' > Main.c
          gcc -O2 -pipe Main.c -o Main
          [ "$(./Main)" = ok ]

  c:
    smoke:
      command:
        - /bin/sh
        - -c
        - |
          printf '%s\n' '#include <stdio.h>' 'int main(void) {' '  puts("ok");' '  return 0;' '}' > Main.c
          gcc -O2 -pipe Main.c -o Main
          [ "$(./Main)" = ok ]

  cpp:
    smoke:
      command:
        - /bin/sh
        - -c
        - |
          printf '%s\n' '#include <iostream>' 'int main() {' '  std::cout << "ok\n";' '  return 0;' '}' > Main.cpp
          g++ -O2 -pipe Main.cpp -o Main
          [ "$(./Main)" = ok ]
          printf '%s\n' \
            '#include "testlib.h"' \
            'int main(int argc, char *argv[]) {' \
            '  registerTestlibCmd(argc, argv);' \
            '  int expected = ans.readInt();' \
            '  int actual = ouf.readInt();' \
            '  if (expected != actual) quitf(_wa, "expected %d, found %d", expected, actual);' \
            '  quitf(_ok, "accepted");' \
            '}' > Checker.cpp
          g++ -std=c++17 -O2 -pipe Checker.cpp -o Checker
          printf '%s\n' '1 2' > input.txt
          printf '%s\n' '3' > answer.txt
          printf '%s\n' '3' > output.txt
          ./Checker input.txt output.txt answer.txt

  aheui:
    install:
      apt:
        - python3
        - python3-pip
      pip:
        - aheui==1.2.5
    smoke:
      command:
        - /bin/sh
        - -c
        - |
          printf '%s' '밞바밤밣받밞밞밞밦밞바밝밣바박박밦밞받밞받밞발밣받뱔희밞땨몋드떠받볋' > Main.aheui
          output="$(aheui Main.aheui 2>/tmp/aheui.stderr || true)"
          printf '%s\n' "${output}" | grep '^Hello, World!$'

  apecode:
    install:
      apt:
        - curl
        - g++
        - python3
        - python3-pip
      script:
        - export APECODE_COMMIT=c7ae98d3dfc1713ecc800422a4c815628776e1e2
        - export APECODE_SHA256=0ff71e149ec49a94211bb44b6a3d55e1290acb1387ca4f5f76a8f42f568ae629
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://codeload.github.com/seo-rii/apecode/tar.gz/${APECODE_COMMIT}" -o /tmp/apecode.tar.gz
        - echo "${APECODE_SHA256}  /tmp/apecode.tar.gz" | sha256sum -c -
        - python3 -m pip install --break-system-packages --no-cache-dir /tmp/apecode.tar.gz
        - rm -f /tmp/apecode.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'state main {' '  return true;' '}' > Main.ape
          apecc --check Main.ape
          apecc -o Main Main.ape
          printf '%s\n' 1 3 '3 1 2' | ./Main | grep '^3 1 2$'

  asm:
    install:
      apt:
        - gcc
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.s <<'ASM'
          .global _start
          .section .text
          _start:
              mov $1, %rax
              mov $1, %rdi
              lea msg(%rip), %rsi
              mov $3, %rdx
              syscall
              mov $60, %rax
              xor %rdi, %rdi
              syscall
          .section .rodata
          msg:
              .ascii "ok\n"
          ASM
          gcc -nostdlib -static -no-pie Main.s -o Main
          ./Main | grep '^ok$'
          cat > Broken.s <<'ASM'
          .global _start
          .section .text
          _start:
              mov %rax, $1
          ASM
          if gcc -nostdlib -static -no-pie Broken.s -o Broken >/dev/null 2>&1; then exit 1; fi

  nasm:
    install:
      apt:
        - gcc
        - nasm
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.asm <<'ASM'
          default rel
          global _start
          section .text
          _start:
              mov rax, 1
              mov rdi, 1
              lea rsi, [rel msg]
              mov rdx, msg_len
              syscall
              mov rax, 60
              xor rdi, rdi
              syscall
          section .rodata
          msg: db "ok", 10
          msg_len equ $ - msg
          ASM
          nasm -felf64 Main.asm -o Main.o
          gcc -nostdlib -static -no-pie Main.o -o Main
          ./Main | grep '^ok$'
          cat > Broken.asm <<'ASM'
          global _start
          section .text
          _start:
              mov raxx, 60
          ASM
          if nasm -felf64 Broken.asm -o Broken.o >/dev/null 2>&1; then exit 1; fi

  python:
    install:
      apt:
        - python3
        - python3-pip
      pip:
        - setuptools==80.10.2
        - numpy==2.4.4
        - pandas==3.0.2
        - seaborn==0.13.2
        - matplotlib==3.10.8
        - pillow==12.3.0
        - six==1.17.0
        - qiskit==2.4.0
        - pyparsing==3.3.2
        - pylatexenc==2.10
        - jax[cpu]==0.10.0
      script:
        - python3 -m pip install --break-system-packages --no-cache-dir --index-url https://download.pytorch.org/whl/cpu torch==2.11.0+cpu torchvision==0.26.0+cpu
    smoke:
      command:
        - python3
        - -c
        - |
          import jax.numpy as jnp
          import os
          import pathlib
          import numpy as np
          import pandas as pd
          import PIL.Image
          import qiskit
          import seaborn as sns
          import torch
          total = int(np.arange(5).sum())
          assert int(pd.Series([1, 2, 3]).sum()) == 6
          assert torch.tensor([1, 2]).sum().item() == 3
          assert int(jnp.arange(5).sum()) == 10
          assert callable(PIL.Image.new)
          assert callable(qiskit.QuantumCircuit)
          assert sns.__version__
          assert "/usr/local/lib/aonohako/python" in os.environ.get("PYTHONPATH", "")
          pathlib.Path("same-folder.txt").write_text(str(total), encoding="utf-8")
          assert pathlib.Path("same-folder.txt").read_text(encoding="utf-8") == "10"

  pypy:
    install:
      apt:
        - pypy3
    smoke:
      command:
        - pypy3
        - -c
        - |
          import sys
          from pathlib import Path
          assert sys.implementation.name == "pypy"
          Path("same-folder.txt").write_text("ok", encoding="utf-8")
          print(Path("same-folder.txt").read_text(encoding="utf-8"))

  java:
    install:
      apt:
        - bash
        - default-jdk-headless
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'public class Main {' '  public static void main(String[] args) {' '    System.out.println("ok");' '  }' '}' > Main.java
          javac --release 11 -encoding UTF-8 Main.java
          printf '%s\n' 'Manifest-Version: 1.0' 'Main-Class: Main' '' > MANIFEST.MF
          jar cfm Main.jar MANIFEST.MF Main.class
          java -XX:ReservedCodeCacheSize=64m -XX:-UseCompressedClassPointers -Xmx128m -Xss1m -XX:MaxDirectMemorySize=16m -XX:MaxMetaspaceSize=64m -Dfile.encoding=UTF-8 -XX:+UseSerialGC -DONLINE_JUDGE=1 -jar Main.jar | grep '^ok$'

  groovy:
    install:
      apt:
        - bash
        - default-jdk-headless
        - groovy
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.groovy <<'GROOVY'
          class Main {
              static void main(String[] args) {
                  new File("same-folder.txt").text = "ok"
                  println new File("same-folder.txt").text.trim()
              }
          }
          GROOVY
          groovyc -d . Main.groovy
          shopt -s nullglob
          groovy_jars=(/usr/share/groovy/embeddable/groovy-all*.jar /usr/share/java/groovy-all*.jar /usr/share/java/groovy*.jar)
          groovy_cp='.'
          for jar in "${groovy_jars[@]}"; do groovy_cp="${groovy_cp}:${jar}"; done
          java -Xmx128m -Xss1m -XX:+UseSerialGC -XX:ReservedCodeCacheSize=32m -XX:MaxDirectMemorySize=16m -XX:MaxMetaspaceSize=192m -XX:CompressedClassSpaceSize=64m -Dfile.encoding=UTF-8 -DONLINE_JUDGE=1 -cp "${groovy_cp}" Main | grep '^ok$'
          cat > Broken.groovy <<'GROOVY'
          class Broken {
              static void main(String[] args) {
                  println(
              }
          }
          GROOVY
          if groovyc -d . Broken.groovy >/dev/null 2>&1; then exit 1; fi

  scala:
    install:
      apt:
        - bash
        - default-jdk-headless
        - scala
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'object Main extends App {' '  val path = new java.io.File("same-folder.txt")' '  val writer = new java.io.PrintWriter(path, "UTF-8")' '  writer.write("ok")' '  writer.close()' '  println(scala.io.Source.fromFile(path, "UTF-8").mkString.trim)' '}' > Main.scala
          scalac Main.scala
          shopt -s nullglob
          scala_jars=(/usr/share/java/scala*.jar)
          scala_cp='.'
          for jar in "${scala_jars[@]}"; do scala_cp="${scala_cp}:${jar}"; done
          java -Xmx128m -Xss1m -XX:+UseSerialGC -XX:ReservedCodeCacheSize=32m -XX:MaxDirectMemorySize=16m -XX:MaxMetaspaceSize=192m -XX:CompressedClassSpaceSize=64m -Dfile.encoding=UTF-8 -DONLINE_JUDGE=1 -cp "${scala_cp}" Main | grep '^ok$'

  javascript:
    install:
      shared:
        - node24
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.js <<'JS'
          const fs = require('fs');
          fs.writeFileSync('same-folder.txt', 'ok');
          console.log(fs.readFileSync('same-folder.txt', 'utf8'));
          JS
          node --disable-wasm-trap-handler --max-old-space-size=64 --max-semi-space-size=1 --stack-size=2048 Main.js | grep '^ok$'

  coffeescript:
    install:
      apt:
        - coffeescript
      script:
        - ln -sfn /usr/bin/coffee /usr/local/bin/coffee
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' "fs = require 'fs'" "fs.writeFileSync 'same-folder.txt', 'ok'" "console.log fs.readFileSync('same-folder.txt', 'utf8')" > Main.coffee
          coffee --compile --bare --output . Main.coffee
          node --disable-wasm-trap-handler --max-old-space-size=64 --max-semi-space-size=1 --stack-size=2048 /usr/local/bin/coffee Main.coffee | grep '^ok$'

  typescript:
    install:
      shared:
        - node24
      npm:
        - typescript
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' "declare const require: any;" "const fs = require('fs');" "fs.writeFileSync('same-folder.txt', 'ok');" "console.log(fs.readFileSync('same-folder.txt', 'utf8'));" > Main.ts
          tsc Main.ts --module commonjs --target es2019 --outDir dist
          node --disable-wasm-trap-handler --max-old-space-size=64 --max-semi-space-size=1 --stack-size=2048 dist/Main.js | grep '^ok$'

  elm:
    install:
      apt:
        - elm-compiler
        - nodejs
      script:
        - install -d -m 0755 /usr/local/lib/aonohako/elm-home
        - |
          export HOME=/usr/local/lib/aonohako/elm-home
          cat > /tmp/elm.json <<'JSON'
          {
            "type": "application",
            "source-directories": ["."],
            "elm-version": "0.19.1",
            "dependencies": {
              "direct": {
                "elm/core": "1.0.5",
                "elm/json": "1.1.3"
              },
              "indirect": {}
            },
            "test-dependencies": {
              "direct": {},
              "indirect": {}
            }
          }
          JSON
          cat > /tmp/Main.elm <<'ELM'
          port module Main exposing (main)
          import Platform
          port stdin : (String -> msg) -> Sub msg
          port stdout : String -> Cmd msg
          type Msg = Input String
          main : Program () () Msg
          main =
              Platform.worker
                  { init = \_ -> ( (), Cmd.none )
                  , update = \msg model ->
                      case msg of
                          Input input ->
                              ( model, stdout input )
                  , subscriptions = \_ -> stdin Input
                  }
          ELM
          cd /tmp && printf 'y\n' | elm make Main.elm --output=/tmp/elm-warmup.js
          chmod -R a+rX /usr/local/lib/aonohako/elm-home
          rm -f /tmp/elm.json /tmp/Main.elm /tmp/elm-warmup.js
    smoke:
      command:
        - bash
        - -lc
        - |
          set -euo pipefail
          tmp="$(mktemp -d)"
          trap 'rm -rf "$tmp"' EXIT
          cd "$tmp"
          export HOME=/usr/local/lib/aonohako/elm-home
          cat > elm.json <<'JSON'
          {
            "type": "application",
            "source-directories": ["."],
            "elm-version": "0.19.1",
            "dependencies": {
              "direct": {
                "elm/core": "1.0.5",
                "elm/json": "1.1.3"
              },
              "indirect": {}
            },
            "test-dependencies": {
              "direct": {},
              "indirect": {}
            }
          }
          JSON
          cat > Main.elm <<'ELM'
          port module Main exposing (main)
          import Platform
          port stdin : (String -> msg) -> Sub msg
          port stdout : String -> Cmd msg
          type Msg = Input String
          main : Program () () Msg
          main =
              Platform.worker
                  { init = \_ -> ( (), Cmd.none )
                  , update = \msg model ->
                      case msg of
                          Input input ->
                              ( model, stdout input )
                  , subscriptions = \_ -> stdin Input
                  }
          ELM
          elm make Main.elm --output=aonohako-elm-compiled.js
          {
            printf '%s\n' 'const fs = require("fs");' 'const __aonohakoInput = fs.readFileSync(0, "utf8");'
            cat aonohako-elm-compiled.js
            cat <<'JS'
          const __aonohakoElm = typeof Elm !== "undefined" ? Elm : (typeof module !== "undefined" && module.exports ? module.exports.Elm : undefined);
          const __aonohakoApp = __aonohakoElm.Main.init({ flags: null });
          const __aonohakoPorts = __aonohakoApp && __aonohakoApp.ports ? __aonohakoApp.ports : {};
          if (__aonohakoPorts.stdout) {
            __aonohakoPorts.stdout.subscribe((value) => process.stdout.write(String(value)));
          }
          if (__aonohakoPorts.stdin) {
            __aonohakoPorts.stdin.send(__aonohakoInput);
          }
          JS
          } > Main.js
          printf 'ok\n' | node --disable-wasm-trap-handler --max-old-space-size=64 --max-semi-space-size=1 --stack-size=2048 Main.js | grep '^ok$'
          cat > Broken.elm <<'ELM'
          module Broken exposing (main)
          main =
          ELM
          if elm make Broken.elm --output=Broken.js >/dev/null 2>&1; then exit 1; fi

  rescript:
    install:
      shared:
        - node24
      script:
        - npm install -g --prefix /usr/local rescript@12.3.0
    smoke:
      command:
        - bash
        - -lc
        - |
          set -euo pipefail
          tmp="$(mktemp -d)"
          trap 'rm -rf "$tmp"' EXIT
          cd "$tmp"
          cat > rescript.json <<'JSON'
          {
            "name": "aonohako-rescript-smoke",
            "sources": [
              { "dir": ".", "subdirs": false }
            ],
            "package-specs": {
              "module": "commonjs",
              "in-source": false
            },
            "suffix": ".js"
          }
          JSON
          printf '%s\n' 'Console.log("ok")' > Main.res
          rescript build
          node --disable-wasm-trap-handler --max-old-space-size=64 --max-semi-space-size=1 --stack-size=2048 lib/js/Main.js | grep '^ok$'
          printf '%s\n' 'let broken = ' > Broken.res
          if rescript build >/dev/null 2>&1; then exit 1; fi

  purescript:
    install:
      shared:
        - node24
      sandbox_tools:
        - git
      apt:
        - git
      script:
        - npm install -g --prefix /usr/local purescript@0.15.16 spago@1.0.4
        - install -d -m 0755 /usr/local/lib/aonohako/purescript-home
        - |
          export HOME=/usr/local/lib/aonohako/purescript-home
          tmp=/tmp/purescript-warmup
          rm -rf "$tmp"
          mkdir -p "$tmp/src"
          cat > "$tmp/spago.yaml" <<'YAML'
          package:
            name: aonohako-purescript-warmup
            dependencies:
              - console
              - effect
              - prelude
            test:
              main: Test.Main
              dependencies: []
          workspace:
            packageSet:
              registry: 77.4.1
            extraPackages: {}
          YAML
          cat > "$tmp/src/Main.purs" <<'PURS'
          module Main where
          import Prelude
          import Effect (Effect)
          import Effect.Console (log)
          main :: Effect Unit
          main = log "ok"
          PURS
          cd "$tmp" && spago build
          chmod -R a+rX /usr/local/lib/aonohako/purescript-home
          cd /
          rm -rf "$tmp"
    smoke:
      command:
        - bash
        - -lc
        - |
          set -euo pipefail
          tmp="$(mktemp -d)"
          trap 'rm -rf "$tmp"' EXIT
          cd "$tmp"
          export HOME=/usr/local/lib/aonohako/purescript-home
          cat > spago.yaml <<'YAML'
          package:
            name: aonohako-purescript-smoke
            dependencies:
              - console
              - effect
              - prelude
            test:
              main: Test.Main
              dependencies: []
          workspace:
            packageSet:
              registry: 77.4.1
            extraPackages: {}
          YAML
          mkdir -p src
          cat > src/Main.purs <<'PURS'
          module Main where
          import Prelude
          import Effect (Effect)
          import Effect.Console (log)
          main :: Effect Unit
          main = log "ok"
          PURS
          spago build
          printf '%s\n' 'require("./output/Main/index.js").main();' > Main.js
          node --disable-wasm-trap-handler --max-old-space-size=64 --max-semi-space-size=1 --stack-size=2048 Main.js | grep '^ok$'
          cat > src/Broken.purs <<'PURS'
          module Broken where
          broken =
          PURS
          if spago build >/dev/null 2>&1; then exit 1; fi

  ruby:
    install:
      apt:
        - ruby-full
    smoke:
      command:
        - ruby
        - -e
        - |
          File.write("same-folder.txt", "ok")
          puts File.read("same-folder.txt")

  php:
    install:
      apt:
        - php
    smoke:
      command:
        - php
        - -r
        - |
          file_put_contents("same-folder.txt", "ok");
          echo file_get_contents("same-folder.txt"), PHP_EOL;

  lua:
    install:
      apt:
        - lua5.4
    smoke:
      command:
        - lua5.4
        - -e
        - |
          local f = assert(io.open("same-folder.txt", "w"))
          f:write("ok")
          f:close()
          local r = assert(io.open("same-folder.txt", "r"))
          print(r:read("*a"))
          r:close()

  perl:
    install:
      apt:
        - perl
    smoke:
      command:
        - perl
        - -e
        - |
          open my $fh, '>', 'same-folder.txt' or die $!;
          print {$fh} "ok";
          close $fh;
          open my $rfh, '<', 'same-folder.txt' or die $!;
          print scalar <$rfh>;
          close $rfh;

  elixir:
    install:
      apt:
        - elixir
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'File.write!("same-folder.txt", "ok")' 'IO.puts(File.read!("same-folder.txt"))' > Main.exs
          env ERL_AFLAGS='+MIscs 128 +S 1:1 +A 1 +MMscs 0' elixir Main.exs | grep '^ok$'

  haskell:
    install:
      apt:
        - ghc
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'main :: IO ()' 'main = do' '  writeFile "same-folder.txt" "ok"' '  readFile "same-folder.txt" >>= putStrLn' > Main.hs
          ghc -O2 -o Main Main.hs
          ./Main | grep '^ok$'

  idris2:
    install:
      apt:
        - bash
        - build-essential
        - ca-certificates
        - chezscheme
        - curl
        - libgmp-dev
        - make
      script:
        - export IDRIS2_VERSION=0.8.0
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/idris-lang/Idris2/archive/refs/tags/v${IDRIS2_VERSION}.tar.gz" -o /tmp/idris2.tar.gz
        - tar -xzf /tmp/idris2.tar.gz -C /tmp
        - IDRIS2_SRC="$(find /tmp -maxdepth 1 -type d -name 'Idris2-*' | head -n 1)"; test -n "${IDRIS2_SRC}"; cd "${IDRIS2_SRC}" && make bootstrap SCHEME=chezscheme PREFIX=/usr/local && make install PREFIX=/usr/local
        - rm -rf /tmp/Idris2-* /tmp/idris2.tar.gz
        - cd /
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.idr <<'IDRIS'
          module Main

          main : IO ()
          main = putStrLn "ok"
          IDRIS
          idris2 --cg chez -o Main Main.idr
          ./build/exec/Main | grep '^ok$'
          test -d build/exec/Main_app
          cat > Broken.idr <<'IDRIS'
          module Broken

          main : IO ()
          main =
          IDRIS
          if idris2 --cg chez -o Broken Broken.idr >/dev/null 2>&1; then exit 1; fi

  haxe:
    install:
      apt:
        - haxe
        - neko
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.hx <<'HAXE'
          class Main {
            static public function main() {
              Sys.println("ok");
            }
          }
          HAXE
          haxe -main Main -neko Main.n
          neko Main.n | grep '^ok$'

  lisp:
    install:
      apt:
        - sbcl
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.lisp <<'LISP'
          (with-open-file (out "same-folder.txt"
                               :direction :output
                               :if-exists :supersede
                               :if-does-not-exist :create)
            (write-line "ok" out))
          (with-open-file (in "same-folder.txt" :direction :input)
            (format t "~a~%" (read-line in nil "")))
          LISP
          sbcl --noinform --script Main.lisp | grep '^ok$'
          cat > Broken.lisp <<'LISP'
          (format t "ok"
          LISP
          if sbcl --noinform --script Broken.lisp >/dev/null 2>&1; then exit 1; fi

  picolisp:
    install:
      apt:
        - picolisp
    smoke:
      command:
        - bash
        - -lc
        - |
          pil -version -bye >/dev/null
          cat > Main.l <<'PICOLISP'
          (in NIL
             (let (A (read) B (read))
                (prinl (+ A B)) ) )
          PICOLISP
          printf '1 2\n' | pil Main.l -bye | grep '^3$'
          printf '%s\n' '(prinl "broken"' > Broken.l
          if pil Broken.l -bye >/dev/null 2>&1; then exit 1; fi

  swift:
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'import Foundation' 'try! "ok".write(toFile: "same-folder.txt", atomically: true, encoding: .utf8)' 'print(try! String(contentsOfFile: "same-folder.txt").trimmingCharacters(in: .whitespacesAndNewlines))' > Main.swift
          swiftc -O Main.swift -o Main
          ./Main | grep '^ok$'

  sqlite:
    install:
      apt:
        - sqlite3
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'create table numbers(v integer);' 'insert into numbers(v) values (1),(2),(3);' > setup.sql
          printf '%s\n' 'select sum(v) from numbers;' > Main.sql
          [ "$(sqlite3 same-folder.db '.read setup.sql' '.read Main.sql')" = 6 ]
          [ -f same-folder.db ]

  julia:
    install:
      script:
        - ln -sfn /usr/local/julia/bin/julia /usr/local/bin/julia
    smoke:
      command:
        - julia
        - --startup-file=no
        - --history-file=no
        - --color=no
        - -e
        - |
          using Statistics
          open("same-folder.txt", "w") do io
              write(io, string(mean([1, 2, 3])))
          end
          println(read("same-folder.txt", String))

  raku:
    install:
      apt:
        - raku
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'spurt "same-folder.txt", "ok";' 'say slurp("same-folder.txt").trim;' > Main.raku
          raku -c Main.raku >/dev/null
          raku Main.raku | grep '^ok$'

  r:
    install:
      apt:
        - r-base-core
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.R <<'RS'
          writeLines("ok", "same-folder.txt")
          cat(readLines("same-folder.txt"), sep = "\n")
          RS
          Rscript --vanilla Main.R | grep '^ok$'
          cat > Broken.R <<'RS'
          if (
          RS
          if Rscript --vanilla -e "parse(file=commandArgs(TRUE)[1])" Broken.R >/dev/null 2>&1; then exit 1; fi

  erlang:
    install:
      apt:
        - erlang-base
        - erlang-dev
        - erlang-parsetools
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > main.erl <<'ERL'
          -module(main).
          -export([main/0]).
          main() ->
              ok = file:write_file("same-folder.txt", <<"ok">>),
              {ok, Data} = file:read_file("same-folder.txt"),
              io:format("~s~n", [Data]).
          ERL
          erlc main.erl
          erl +S 1:1 +A 1 -noshell -pa . -s main main -s init stop | grep '^ok$'
          cat > Broken.erl <<'ERL'
          -module(broken).
          -export([main/0]).
          main() ->
              ok =
          ERL
          if erlc Broken.erl >/dev/null 2>&1; then exit 1; fi

  prolog:
    install:
      apt:
        - swi-prolog-nox
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.pl <<'PROLOG'
          main :-
              setup_call_cleanup(
                  open('same-folder.txt', write, Out),
                  write(Out, ok),
                  close(Out)
              ),
              setup_call_cleanup(
                  open('same-folder.txt', read, In),
                  read_string(In, _, Content),
                  close(In)
              ),
              writeln(Content).
          PROLOG
          swipl -q -f Main.pl -g main -t halt | grep '^ok$'
          cat > Broken.pl <<'PROLOG'
          main :-
              writeln(ok
          PROLOG
          if swipl -q -f Broken.pl -g main -t halt >/dev/null 2>&1; then exit 1; fi

  whitespace:
    install:
      apt:
        - python3
    smoke:
      command:
        - bash
        - -lc
        - |
          python3 - <<'PY' > Main.ws
          S = " "
          T = "\t"
          L = "\n"
          def number(value):
              sign = S if value >= 0 else T
              bits = bin(abs(value))[2:]
              payload = ''.join(S if ch == '0' else T for ch in bits)
              return sign + payload + L
          def push(value):
              return S + S + number(value)
          def out_char():
              return T + L + S + S
          program = ''.join(push(ord(ch)) + out_char() for ch in "ok\n") + L + L + L
          print(program, end="")
          PY
          python3 /usr/local/lib/aonohako/whitespace.py Main.ws | grep '^ok$'

  bf:
    install:
      apt:
        - python3
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s' '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.' > Main.bf
          python3 /usr/local/lib/aonohako/brainfuck.py Main.bf | grep '^Hello World!$'

  befunge:
    install:
      apt:
        - python3
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s' '>"ko",,91+,@' > Main.bef
          python3 /usr/local/lib/aonohako/befunge.py Main.bef | grep '^ok$'

  malbolge:
    install:
      apt:
        - python3
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.mal <<'MALBOLGE'
          ('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=<M:9wv6WsU2T|nm-,jcL(I&%$#"`CB]V?Tx<uVtT`Rpo3NlF.Jh++FdbCBA@?]!~|4XzyTT43Qsqq(Lnmkj"Fhg${z@>
          MALBOLGE
          [ "$(python3 /usr/local/lib/aonohako/malbolge.py Main.mal)" = 'Hello World!' ]

  lolcode:
    install:
      apt:
        - cmake
        - curl
        - gcc
        - libc6-dev
        - libreadline-dev
        - make
      script:
        - export LCI_VERSION=0.11.2
        - export LCI_SHA256=cb1065936d3a7463928dcddfc345a8d7d8602678394efc0e54981f9dd98c27d2
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://codeload.github.com/justinmeza/lci/tar.gz/v${LCI_VERSION}" -o /tmp/lci.tar.gz
        - echo "${LCI_SHA256}  /tmp/lci.tar.gz" | sha256sum -c -
        - tar -xzf /tmp/lci.tar.gz -C /tmp
        - cmake -S "/tmp/lci-${LCI_VERSION}" -B /tmp/lci-build -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local
        - cmake --build /tmp/lci-build --parallel "$(nproc)"
        - cmake --install /tmp/lci-build
        - rm -rf /tmp/lci.tar.gz "/tmp/lci-${LCI_VERSION}" /tmp/lci-build
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'HAI 1.2' 'VISIBLE "ok"' 'KTHXBYE' > Main.lol
          lci Main.lol | grep '^ok$'

  wasm:
    install:
      apt:
        - curl
        - wabt
        - xz-utils
      script:
        - export WASMTIME_VERSION=44.0.0
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/bytecodealliance/wasmtime/releases/download/v${WASMTIME_VERSION}/wasmtime-v${WASMTIME_VERSION}-x86_64-linux.tar.xz" -o /tmp/wasmtime.tar.xz
        - install -d /tmp/wasmtime
        - tar -xJf /tmp/wasmtime.tar.xz -C /tmp/wasmtime --strip-components=1
        - install -m 0755 /tmp/wasmtime/wasmtime /usr/local/bin/wasmtime
        - rm -rf /tmp/wasmtime /tmp/wasmtime.tar.xz
        - test -x /usr/local/bin/wasmtime
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.wat <<'WAT'
          (module
            (import "wasi_snapshot_preview1" "fd_write"
              (func $fd_write (param i32 i32 i32 i32) (result i32)))
            (memory 1)
            (export "memory" (memory 0))
            (data (i32.const 8) "ok\n")
            (func (export "_start")
              i32.const 0
              i32.const 8
              i32.store
              i32.const 4
              i32.const 3
              i32.store
              i32.const 1
              i32.const 0
              i32.const 1
              i32.const 20
              call $fd_write
              drop))
          WAT
          wat2wasm Main.wat -o Main.wasm
          wasmtime run --dir=. \
            -O memory-reservation=33554432 \
            -O memory-reservation-for-growth=0 \
            -O memory-guard-size=65536 \
            -W max-memory-size=33554432 \
            -W max-memories=1 \
            -W max-instances=1 \
            -W max-tables=1 \
            -W max-table-elements=65536 \
            -W max-wasm-stack=1048576 \
            -W trap-on-grow-failure=y \
            Main.wasm | grep '^ok$'

  ocaml:
    install:
      apt:
        - ocaml-nox
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'print_endline "ok"' > Main.ml
          ocamlopt -o Main Main.ml
          env OCAMLRUNPARAM='s=32k' ./Main | grep '^ok$'

  sml:
    install:
      apt:
        - curl
        - gcc
        - g++
        - libc6-dev
        - libgmp-dev
        - make
      script:
        - export MLTON_VERSION=20241230
        - curl --retry 8 --retry-all-errors --retry-delay 3 --connect-timeout 20 -fL "https://downloads.sourceforge.net/project/mlton/mlton/${MLTON_VERSION}/mlton-${MLTON_VERSION}-1.amd64-linux.ubuntu-20.04_static.tgz" -o /tmp/mlton.tgz
        - tar -xzf /tmp/mlton.tgz -C /opt
        - rm -f /tmp/mlton.tgz
        - MLTON_DIR="$(find /opt -maxdepth 1 -type d -name "mlton-${MLTON_VERSION}-*" | head -n 1)"; ln -sfn "${MLTON_DIR}/bin/mlton" /usr/local/bin/mlton; ln -sfn "${MLTON_DIR}/lib/mlton" /usr/local/lib/mlton
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.sml <<'SML'
          val out = TextIO.openOut "same-folder.txt"
          val _ = TextIO.output (out, "ok\n")
          val _ = TextIO.closeOut out
          val inp = TextIO.openIn "same-folder.txt"
          val line = TextIO.inputLine inp
          val _ = TextIO.closeIn inp
          val _ = case line of SOME s => print s | NONE => ()
          SML
          mlton -output Main Main.sml
          ./Main | grep '^ok$'
          cat > Broken.sml <<'SML'
          val _ = print (
          SML
          if mlton -output Broken Broken.sml >/dev/null 2>&1; then exit 1; fi

  mercury:
    install:
      apt:
        - ca-certificates
        - curl
        - gcc
        - libc6-dev
      script:
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL https://paul.bone.id.au/paul.asc -o /etc/apt/trusted.gpg.d/paulbone.asc
        - echo 'deb https://dl.mercurylang.org/deb/ trixie main' > /etc/apt/sources.list.d/mercury.list
        - apt-get update -o APT::Get::List-Cleanup=false
        - DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends mercury-recommended
        - apt-get clean
        - rm -rf /var/lib/apt/lists/*
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > main.m <<'MERCURY'
          :- module main.
          :- interface.
          :- import_module io.
          :- pred main(io::di, io::uo) is det.
          :- implementation.

          main(!IO) :-
              io.write_string("ok\n", !IO).
          MERCURY
          mmc --make --grade hlc.gc main
          ./main | grep '^ok$'
          cat > broken.m <<'MERCURY'
          :- module broken.
          :- interface.
          :- import_module io.
          :- pred main(io::di, io::uo) is det.
          :- implementation.

          main(!IO) :-
          MERCURY
          if mmc --make --grade hlc.gc broken >/dev/null 2>&1; then exit 1; fi

  go:
    install:
      apt:
        - gcc
      script:
        - ln -sfn /usr/local/go/bin/go /usr/local/bin/go
        - ln -sfn /usr/local/go/bin/gofmt /usr/local/bin/gofmt
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'package main' 'import "fmt"' 'func main() { fmt.Println("ok") }' > main.go
          env -u GOROOT GOENV=off go build -o Main main.go
          ./Main | grep '^ok$'

  zig:
    install:
      apt:
        - curl
        - xz-utils
      script:
        - export ZIG_VERSION=0.14.0
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://ziglang.org/download/${ZIG_VERSION}/zig-linux-x86_64-${ZIG_VERSION}.tar.xz" -o /tmp/zig.tar.xz
        - mkdir -p /opt
        - tar -xJf /tmp/zig.tar.xz -C /opt
        - ln -sfn "/opt/zig-linux-x86_64-${ZIG_VERSION}/zig" /usr/local/bin/zig
        - rm -f /tmp/zig.tar.xz
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.zig <<'ZIG'
          const std = @import("std");
          pub fn main() !void {
              try std.fs.cwd().writeFile(.{ .sub_path = "same-folder.txt", .data = "ok" });
              const data = try std.fs.cwd().readFileAlloc(std.heap.page_allocator, "same-folder.txt", 16);
              defer std.heap.page_allocator.free(data);
              try std.io.getStdOut().writer().print("{s}\n", .{data});
          }
          ZIG
          zig build-exe Main.zig -O ReleaseSafe -mcpu=baseline -femit-bin=Main
          ./Main | grep '^ok$'
          cat > Broken.zig <<'ZIG'
          pub fn main() void {
              this is invalid
          }
          ZIG
          if zig build-exe Broken.zig -O ReleaseSafe -mcpu=baseline -femit-bin=Broken >/dev/null 2>&1; then exit 1; fi

  fortran:
    install:
      apt:
        - gfortran
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.f90 <<'F90'
          program main
            implicit none
            character(len=32) :: line
            open(unit=10, file='same-folder.txt', status='replace', action='write')
            write(10, '(A)') 'ok'
            close(10)
            open(unit=11, file='same-folder.txt', status='old', action='read')
            read(11, '(A)') line
            close(11)
            print '(A)', trim(line)
          end program main
          F90
          gfortran -O2 -pipe Main.f90 -o Main
          ./Main | grep '^ok$'
          cat > Broken.f90 <<'F90'
          program broken
            integer :: x
            x =
          end program broken
          F90
          if gfortran -O2 -pipe Broken.f90 -o Broken >/dev/null 2>&1; then exit 1; fi

  d:
    install:
      apt:
        - gcc
        - libc6-dev
        - ldc
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.d <<'D'
          import std.file : write, readText;
          import std.stdio : writeln;
          void main() {
              write("same-folder.txt", "ok");
              writeln(readText("same-folder.txt"));
          }
          D
          ldc2 Main.d -O3 -release -of=Main
          ./Main | grep '^ok$'
          cat > Broken.d <<'D'
          void main() {
              this is invalid;
          }
          D
          if ldc2 Broken.d -O3 -release -of=Broken >/dev/null 2>&1; then exit 1; fi

  objective-c:
    install:
      shared:
        - libobjc16
      apt:
        - clang
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.m <<'OBJC'
          #include <stdio.h>
          int main(void) {
              puts("ok");
              return 0;
          }
          OBJC
          clang -x objective-c -O2 -pipe Main.m -o Main -L/usr/lib/gcc/x86_64-linux-gnu/16 -lobjc
          ./Main | grep '^ok$'

  objective-cpp:
    install:
      shared:
        - libobjc16
      apt:
        - clang
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.mm <<'OBJCPP'
          #include <iostream>
          int main() {
              std::cout << "ok\n";
              return 0;
          }
          OBJCPP
          clang++ -x objective-c++ -O2 -pipe Main.mm -o Main -L/usr/lib/gcc/x86_64-linux-gnu/16 -lobjc
          ./Main | grep '^ok$'

  coq:
    install:
      apt:
        - coq
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.v <<'COQ'
          Theorem same_folder_ok : 1 = 1.
          Proof. reflexivity. Qed.
          COQ
          coqc -q Main.v
          [ -f Main.vo ]
          cat > Broken.v <<'COQ'
          Theorem broken : 1 = 2.
          Proof. reflexivity. Qed.
          COQ
          if coqc -q Broken.v >/dev/null 2>&1; then exit 1; fi

  rocq:
    install:
      apt:
        - coq
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.v <<'COQ'
          Theorem same_folder_ok : 1 = 1.
          Proof. reflexivity. Qed.
          COQ
          if command -v rocq >/dev/null 2>&1; then
            rocq c Main.v
          else
            coqc -q Main.v
          fi
          [ -f Main.vo ]

  scheme:
    install:
      apt:
        - build-essential
        - git
        - make
      script:
        - export CHIBI_COMMIT=97faa0bf2d123c558d7ab79216906567c44cb03c
        - git clone https://github.com/ashinn/chibi-scheme /opt/chibi-scheme
        - cd /opt/chibi-scheme && git checkout "${CHIBI_COMMIT}" && make && make install
        - chibi-scheme -V
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.scm <<'SCM'
          (import (scheme base) (scheme write))
          (display "ok")
          (newline)
          SCM
          chibi-scheme Main.scm | grep '^ok$'

  awk:
    install:
      apt:
        - gawk
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'BEGIN { print "ok" }' > Main.awk
          gawk --sandbox -f Main.awk | grep '^ok$'

  tcl:
    install:
      apt:
        - tcl
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'puts "ok"' > Main.tcl
          tclsh Main.tcl | grep '^ok$'

  gdl:
    install:
      apt:
        - gnudatalanguage
        - graphicsmagick
        - imagemagick
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.pro <<'GDL'
          pro main
            print, 'ok'
          end
          GDL
          aonohako-gdl-run Main.pro main | grep 'ok'

  octave:
    install:
      apt:
        - octave
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'disp("ok")' > Main.m
          octave-cli --quiet --no-gui --no-history --no-init-file --no-init-path Main.m | grep '^ok$'

  vhdl:
    install:
      apt:
        - ghdl
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.vhd <<'VHDL'
          entity main_tb is
          end entity;

          architecture sim of main_tb is
          begin
            process
            begin
              assert 1 = 1 report "ok" severity note;
              wait;
            end process;
          end architecture;
          VHDL
          ghdl -a --std=08 Main.vhd
          ghdl -e --std=08 main_tb
          ghdl -r --std=08 main_tb --assert-level=error --stop-time=1ms

  verilog:
    install:
      apt:
        - iverilog
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.v <<'VERILOG'
          module main;
            initial begin
              $display("ok");
              $finish(0);
            end
          endmodule
          VERILOG
          iverilog -g2012 -o sim.vvp Main.v
          vvp sim.vvp | grep '^ok$'

  systemverilog:
    install:
      apt:
        - iverilog
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.sv <<'SV'
          module main;
            logic ok = 1'b1;
            initial begin
              if (ok) $display("ok");
              $finish(0);
            end
          endmodule
          SV
          iverilog -g2012 -o sim.vvp Main.sv
          vvp sim.vvp | grep '^ok$'

  crystal:
    install:
      apt:
        - crystal
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'puts "ok"' > Main.cr
          crystal build Main.cr --release --no-debug -o Main
          ./Main | grep '^ok$'
          printf '%s\n' 'puts(' > Broken.cr
          if crystal build Broken.cr --release --no-debug -o Broken >/dev/null 2>&1; then exit 1; fi

  vala:
    install:
      apt:
        - gcc
        - libc6-dev
        - libglib2.0-dev
        - valac
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'int main() {' '  print("ok\n");' '  return 0;' '}' > Main.vala
          valac --define=ONLINE_JUDGE -o Main Main.vala
          ./Main | grep '^ok$'
          printf '%s\n' 'int main() {' '  print(' > Broken.vala
          if valac --define=ONLINE_JUDGE -o Broken Broken.vala >/dev/null 2>&1; then exit 1; fi

  vlang:
    install:
      apt:
        - curl
        - g++
        - gcc
        - libc6-dev
        - unzip
      script:
        - export V_VERSION=0.5.2
        - export V_LINUX_SHA256=86caf9e70c3342d48ef19eb4f6c47b709f18c90ae86255520d5c29df6b482e23
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/vlang/v/releases/download/${V_VERSION}/v_linux.zip" -o /tmp/v_linux.zip
        - echo "${V_LINUX_SHA256}  /tmp/v_linux.zip" | sha256sum -c -
        - install -d -m 0755 /opt
        - unzip -q /tmp/v_linux.zip -d /opt
        - ln -sfn /opt/v/v /usr/local/bin/v
        - rm -f /tmp/v_linux.zip
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' "fn main() {" "  println('ok')" "}" > Main.v
          v -o Main Main.v
          ./Main | grep '^ok$'

  odin:
    install:
      apt:
        - clang
        - curl
        - lld
      script:
        - export ODIN_VERSION=dev-2026-04
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/odin-lang/Odin/releases/download/${ODIN_VERSION}/odin-linux-amd64-${ODIN_VERSION}.tar.gz" -o /tmp/odin.tar.gz
        - mkdir -p /opt/odin
        - tar -xzf /tmp/odin.tar.gz -C /opt/odin --strip-components=1
        - ln -sfn /opt/odin/odin /usr/local/bin/odin
        - rm -f /tmp/odin.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > main.odin <<'ODIN'
          package main
          import "core:fmt"
          main :: proc() {
            fmt.println("ok")
          }
          ODIN
          work="$(mktemp -d)"
          mv main.odin "${work}/main.odin"
          cd "${work}"
          odin build . -out:Main
          ./Main | grep '^ok$'

  c3:
    install:
      apt:
        - curl
      script:
        - export C3_VERSION=0.7.11
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/c3lang/c3c/releases/download/v${C3_VERSION}/c3-linux.tar.gz" -o /tmp/c3.tar.gz
        - mkdir -p /opt
        - tar -xzf /tmp/c3.tar.gz -C /opt
        - ln -sfn /opt/c3/c3c /usr/local/bin/c3c
        - rm -f /tmp/c3.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.c3 <<'C3'
          import std::io;
          fn void main() {
            io::printfn("ok");
          }
          C3
          c3c compile Main.c3 -o Main
          ./Main | grep '^ok$'

  hare:
    install:
      script:
        - apt-get update -o APT::Get::List-Cleanup=false
        - DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends -t sid hare
        - find /var/lib/apt/lists -mindepth 1 -delete
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.ha <<'HARE'
          use fmt;
          export fn main() void = {
            fmt::println("ok")!;
          };
          HARE
          hare build -o Main Main.ha
          ./Main | grep '^ok$'

  rust:
    install:
      apt:
        - curl
        - gcc
        - g++
      script:
        - export RUSTUP_HOME=/usr/local/rustup
        - export CARGO_HOME=/usr/local/cargo
        - export RUST_VERSION=1.95.0
        - export PATH=/usr/local/cargo/bin:$PATH
        - mkdir -p "$RUSTUP_HOME" "$CARGO_HOME"
        - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain "$RUST_VERSION" --no-modify-path
        - ln -sfn /usr/local/cargo/bin/rustc /usr/local/bin/rustc
        - ln -sfn /usr/local/cargo/bin/cargo /usr/local/bin/cargo
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'fn main() {' '    println!("ok");' '}' > main.rs
          rustc --edition 2024 -O -o Main main.rs
          ./Main | grep '^ok$'

  kotlin:
    install:
      apt:
        - curl
        - default-jre-headless
        - xz-utils
      script:
        - export KONAN_VERSION=1.8.10
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/JetBrains/kotlin/releases/download/v${KONAN_VERSION}/kotlin-native-linux-x86_64-${KONAN_VERSION}.tar.gz" -o /tmp/kotlin-native.tar.gz
        - mkdir -p /opt
        - tar -xzf /tmp/kotlin-native.tar.gz -C /opt
        - ln -sfn "/opt/kotlin-native-linux-x86_64-${KONAN_VERSION}/bin/kotlinc-native" /usr/local/bin/kotlinc-native
        - ln -sfn "/opt/kotlin-native-linux-x86_64-${KONAN_VERSION}/bin/run_konan" /usr/local/bin/run_konan
        - rm -f /tmp/kotlin-native.tar.gz
        - mkdir -p /usr/local/lib/aonohako/konan /tmp/.konan.home
        - printf '%s\n' 'fun main() {' '  println("warmup")' '}' > /tmp/KonanWarmup.kt
        - env KONAN_DATA_DIR=/usr/local/lib/aonohako/konan KONAN_USER_HOME=/tmp/.konan.home kotlinc-native -J-Xms64m -J-Xmx1024m -J-Xss1m /tmp/KonanWarmup.kt -o /tmp/KonanWarmup
        - rm -rf /tmp/KonanWarmup.kt /tmp/KonanWarmup.kexe /tmp/.konan.home
        - chmod -R a+rX /usr/local/lib/aonohako/konan
        - touch /usr/local/lib/aonohako/konan/cache/.lock
        - chown 0:0 /usr/local/lib/aonohako/konan/cache/.lock
        - chmod 0400 /usr/local/lib/aonohako/konan/cache/.lock
    smoke:
      command:
        - bash
        - -lc
        - |
          mkdir -p /tmp/.konan /tmp/.konan.home
          printf '%s\n' 'fun main() {' '  println("ok")' '}' > Main.kt
          env KONAN_DATA_DIR=/usr/local/lib/aonohako/konan KONAN_USER_HOME=/tmp/.konan.home kotlinc-native -J-Xms64m -J-Xmx1024m -J-Xss1m Main.kt -o Main
          ./Main.kexe | grep '^ok$'

  pascal:
    install:
      apt:
        - fp-compiler
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.pas <<'PAS'
          program Main;
          var
            F: Text;
            Line: string;
          begin
            Assign(F, 'same-folder.txt');
            Rewrite(F);
            Writeln(F, 'ok');
            Close(F);
            Assign(F, 'same-folder.txt');
            Reset(F);
            ReadLn(F, Line);
            Close(F);
            Writeln(Line);
          end.
          PAS
          fpc -O2 -Xs -oMain Main.pas >/dev/null
          ./Main | grep '^ok$'
          cat > Broken.pas <<'PAS'
          program Broken;
          begin
            Writeln('oops')
          PAS
          if fpc -O2 -Xs -oBroken Broken.pas >/dev/null 2>&1; then exit 1; fi

  delphi:
    install:
      apt:
        - fp-compiler
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.dpr <<'PAS'
          program Main;
          var
            F: TextFile;
            Line: string;
          begin
            AssignFile(F, 'same-folder.txt');
            Rewrite(F);
            Writeln(F, 'ok');
            CloseFile(F);
            AssignFile(F, 'same-folder.txt');
            Reset(F);
            ReadLn(F, Line);
            CloseFile(F);
            Writeln(Line);
          end.
          PAS
          fpc -Mdelphi -O2 -Xs -oMain Main.dpr >/dev/null
          ./Main | grep '^ok$'
          cat > Broken.dpr <<'PAS'
          program Broken;
          begin
            Writeln('oops')
          PAS
          if fpc -Mdelphi -O2 -Xs -oBroken Broken.dpr >/dev/null 2>&1; then exit 1; fi

  objectpascal:
    install:
      apt:
        - fp-compiler
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.pas <<'PAS'
          program Main;
          type
            TOk = class
            public
              class procedure Run;
            end;
          class procedure TOk.Run;
          begin
            Writeln('ok');
          end;
          begin
            TOk.Run;
          end.
          PAS
          fpc -Mobjfpc -O2 -Xs -oMain Main.pas >/dev/null
          ./Main | grep '^ok$'
          cat > Broken.pas <<'PAS'
          program Broken;
          type
            TOk = class
          begin
            Writeln('oops');
          end.
          PAS
          if fpc -Mobjfpc -O2 -Xs -oBroken Broken.pas >/dev/null 2>&1; then exit 1; fi

  nim:
    install:
      apt:
        - curl
        - gcc
        - libc6-dev
        - xz-utils
      script:
        - export PATH="/root/.nimble/bin:${PATH}"
        - curl https://nim-lang.org/choosenim/init.sh -sSf | sh -s -- -y
        - choosenim 2.2.8
        - install -d /usr/local/lib/nim
        - cp -a /root/.choosenim/toolchains/nim-2.2.8/lib /usr/local/lib/nim/
        - install -m 0755 /root/.choosenim/toolchains/nim-2.2.8/bin/nim /usr/local/bin/nim
        - install -m 0755 /root/.choosenim/toolchains/nim-2.2.8/bin/nimble /usr/local/bin/nimble
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.nim <<'NIM'
          import std/[os, strutils]
          writeFile("same-folder.txt", "ok")
          echo readFile("same-folder.txt").strip()
          NIM
          nim c -d:release --opt:speed --out:Main Main.nim >/dev/null
          ./Main | grep '^ok$'
          cat > Broken.nim <<'NIM'
          proc main() =
            echo "oops"
          this is invalid
          NIM
          if nim c -d:release --opt:speed --out:Broken Broken.nim >/dev/null 2>&1; then exit 1; fi

  clojure:
    install:
      apt:
        - clojure
        - default-jre-headless
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.clj <<'CLOJURE'
          (require '[clojure.string :as str])
          (spit "same-folder.txt" "ok")
          (println (str/trim (slurp "same-folder.txt")))
          CLOJURE
          java -Xmx128m -Xss1m -XX:+UseSerialGC -XX:ReservedCodeCacheSize=32m -XX:MaxDirectMemorySize=16m -XX:MaxMetaspaceSize=192m -XX:CompressedClassSpaceSize=64m -Dfile.encoding=UTF-8 -DONLINE_JUDGE=1 -cp /usr/share/java/clojure-1.12.jar clojure.main Main.clj | grep '^ok$'
          cat > Broken.clj <<'CLOJURE'
          (defn broken []
            (println "oops"
          CLOJURE
          if clojure -e "(require '[clojure.java.io :as io]) (with-open [r (java.io.PushbackReader. (io/reader (first *command-line-args*)))] (loop [] (let [form (read {:eof ::eof} r)] (when-not (= form ::eof) (recur)))))" Broken.clj >/dev/null 2>&1; then exit 1; fi

  racket:
    install:
      apt:
        - racket
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.rkt <<'RACKET'
          #lang racket
          (require racket/string)
          (call-with-output-file "same-folder.txt"
            (lambda (out) (displayln "ok" out))
            #:exists 'replace)
          (displayln (string-trim (file->string "same-folder.txt")))
          RACKET
          raco make Main.rkt >/dev/null
          racket Main.rkt | grep '^ok$'
          cat > Broken.rkt <<'RACKET'
          #lang racket
          (displayln "oops"
          RACKET
          if raco make Broken.rkt >/dev/null 2>&1; then exit 1; fi

  ada:
    install:
      apt:
        - gnat
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.adb <<'ADA'
          with Ada.Text_IO; use Ada.Text_IO;
          procedure Main is
            F : File_Type;
          begin
            Create(F, Out_File, "same-folder.txt");
            Put_Line(F, "ok");
            Close(F);
            Open(F, In_File, "same-folder.txt");
            Put_Line(Get_Line(F));
            Close(F);
          end Main;
          ADA
          gnatmake -O2 -o Main Main.adb >/dev/null
          ./Main | grep '^ok$'
          cat > Broken.adb <<'ADA'
          with Ada.Text_IO; use Ada.Text_IO;
          procedure Broken is
          begin
            Put_Line("oops")
          end Broken;
          ADA
          if gnatmake -O2 -o Broken Broken.adb >/dev/null 2>&1; then exit 1; fi

  cobol:
    install:
      apt:
        - gnucobol
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.cob <<'COB'
          IDENTIFICATION DIVISION.
          PROGRAM-ID. Main.
          PROCEDURE DIVISION.
              DISPLAY "ok".
              STOP RUN.
          COB
          cobc -x -free -O2 -o Main Main.cob
          ./Main | grep '^ok$'

  gnucobol:
    install:
      apt:
        - gnucobol
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.cob <<'COB'
          IDENTIFICATION DIVISION.
          PROGRAM-ID. Main.
          PROCEDURE DIVISION.
              DISPLAY "ok".
              STOP RUN.
          COB
          cobc -x -free -O2 -o Main Main.cob
          ./Main | grep '^ok$'

  cython:
    install:
      apt:
        - cython3
        - gcc
        - libc6-dev
        - python3-dev
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'print("ok")' > Main.pyx
          cython3 --embed -3 -o Main.c Main.pyx
          gcc -O2 -pipe Main.c -o Main $(python3-config --includes --ldflags --embed)
          ./Main | grep '^ok$'

  dart:
    install:
      apt:
        - curl
        - unzip
      script:
        - export DART_VERSION=3.11.5
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://storage.googleapis.com/dart-archive/channels/stable/release/${DART_VERSION}/sdk/dartsdk-linux-x64-release.zip" -o /tmp/dartsdk.zip
        - rm -rf /opt/dart-sdk
        - unzip -q /tmp/dartsdk.zip -d /opt
        - ln -sfn /opt/dart-sdk/bin/dart /usr/local/bin/dart
        - rm -f /tmp/dartsdk.zip
        - dart --version
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.dart <<'DART'
          import 'dart:io';
          void main() {
            File('same-folder.txt').writeAsStringSync('ok');
            stdout.writeln(File('same-folder.txt').readAsStringSync().trim());
          }
          DART
          dart compile exe Main.dart -o Main >/dev/null
          ./Main | grep '^ok$'
          cat > Broken.dart <<'DART'
          void main() {
            print('oops'
          }
          DART
          if dart compile exe Broken.dart -o Broken >/dev/null 2>&1; then exit 1; fi

  csharp:
    install:
      apt:
        - curl
        - libicu76
      script:
        - mkdir -p /opt/dotnet
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh
        - bash /tmp/dotnet-install.sh --version 8.0.423 --install-dir /opt/dotnet
        - ln -sfn /opt/dotnet/dotnet /usr/local/bin/dotnet
        - rm -f /tmp/dotnet-install.sh
    smoke:
      command:
        - bash
        - -lc
        - |
          mkdir -p /tmp/csharp-home /tmp/csharp-packages
          env HOME=/tmp/csharp-home DOTNET_CLI_HOME=/tmp/csharp-home NUGET_PACKAGES=/tmp/csharp-packages DOTNET_PROCESSOR_COUNT=1 DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 DOTNET_CLI_TELEMETRY_OPTOUT=1 DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE=1 DOTNET_GENERATE_ASPNET_CERTIFICATE=false DOTNET_NOLOGO=1 MSBuildEnableWorkloadResolver=false dotnet new console --force --no-restore --verbosity quiet -n App -o app
          printf '%s\n' 'Console.WriteLine("ok");' > app/Program.cs
          env HOME=/tmp/csharp-home DOTNET_CLI_HOME=/tmp/csharp-home NUGET_PACKAGES=/tmp/csharp-packages DOTNET_PROCESSOR_COUNT=1 DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 DOTNET_CLI_TELEMETRY_OPTOUT=1 DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE=1 DOTNET_GENERATE_ASPNET_CERTIFICATE=false DOTNET_NOLOGO=1 MSBuildEnableWorkloadResolver=false dotnet publish app --configuration Release -o publish
          env DOTNET_GCHeapHardLimit=8000000 DOTNET_EnableDiagnostics=0 COMPlus_EnableDiagnostics=0 dotnet ./publish/App.dll | grep '^ok$'

  fsharp:
    install:
      apt:
        - curl
        - libicu76
      script:
        - mkdir -p /opt/dotnet
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh
        - bash /tmp/dotnet-install.sh --version 8.0.423 --install-dir /opt/dotnet
        - ln -sfn /opt/dotnet/dotnet /usr/local/bin/dotnet
        - rm -f /tmp/dotnet-install.sh
    smoke:
      command:
        - bash
        - -lc
        - |
          mkdir -p /tmp/fsharp-home /tmp/fsharp-packages
          cat > App.fsproj <<'FSPROJ'
          <Project Sdk="Microsoft.NET.Sdk">
            <PropertyGroup>
              <OutputType>Exe</OutputType>
              <TargetFramework>net8.0</TargetFramework>
            </PropertyGroup>
            <ItemGroup>
              <Compile Include="Program.fs" />
            </ItemGroup>
          </Project>
          FSPROJ
          cat > Program.fs <<'FS'
          open System.IO
          [<EntryPoint>]
          let main _ =
              File.WriteAllText("same-folder.txt", "ok")
              printfn "%s" (File.ReadAllText("same-folder.txt"))
              0
          FS
          env HOME=/tmp/fsharp-home DOTNET_CLI_HOME=/tmp/fsharp-home NUGET_PACKAGES=/tmp/fsharp-packages DOTNET_PROCESSOR_COUNT=1 DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 DOTNET_CLI_TELEMETRY_OPTOUT=1 DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE=1 DOTNET_GENERATE_ASPNET_CERTIFICATE=false DOTNET_NOLOGO=1 MSBuildEnableWorkloadResolver=false dotnet publish App.fsproj --configuration Release -o publish -p:UseAppHost=false
          env DOTNET_GCHeapHardLimit=8000000 DOTNET_EnableDiagnostics=0 COMPlus_EnableDiagnostics=0 dotnet ./publish/App.dll | grep '^ok$'

  vbnet:
    install:
      apt:
        - curl
        - libicu76
      script:
        - mkdir -p /opt/dotnet
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh
        - bash /tmp/dotnet-install.sh --version 8.0.423 --install-dir /opt/dotnet
        - ln -sfn /opt/dotnet/dotnet /usr/local/bin/dotnet
        - rm -f /tmp/dotnet-install.sh
    smoke:
      command:
        - bash
        - -lc
        - |
          mkdir -p /tmp/vbnet-home /tmp/vbnet-packages
          cat > App.vbproj <<'VBPROJ'
          <Project Sdk="Microsoft.NET.Sdk">
            <PropertyGroup>
              <OutputType>Exe</OutputType>
              <TargetFramework>net8.0</TargetFramework>
              <UseAppHost>false</UseAppHost>
              <ImplicitUsings>disable</ImplicitUsings>
            </PropertyGroup>
            <ItemGroup>
              <Compile Include="Program.vb" />
            </ItemGroup>
          </Project>
          VBPROJ
          cat > Program.vb <<'VB'
          Imports System

          Module Program
            Sub Main()
              Console.WriteLine("ok")
            End Sub
          End Module
          VB
          env HOME=/tmp/vbnet-home DOTNET_CLI_HOME=/tmp/vbnet-home NUGET_PACKAGES=/tmp/vbnet-packages DOTNET_PROCESSOR_COUNT=1 DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 DOTNET_CLI_TELEMETRY_OPTOUT=1 DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE=1 DOTNET_GENERATE_ASPNET_CERTIFICATE=false DOTNET_NOLOGO=1 MSBuildEnableWorkloadResolver=false dotnet publish App.vbproj --configuration Release -o publish -p:UseAppHost=false
          env DOTNET_GCHeapHardLimit=8000000 DOTNET_EnableDiagnostics=0 COMPlus_EnableDiagnostics=0 dotnet ./publish/App.dll | grep '^ok$'

  gleam:
    install:
      apt:
        - curl
        - erlang-base
        - erlang-dev
        - erlang-parsetools
      script:
        - export GLEAM_VERSION=1.16.0
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/gleam-lang/gleam/releases/download/v${GLEAM_VERSION}/gleam-v${GLEAM_VERSION}-x86_64-unknown-linux-musl.tar.gz" -o /tmp/gleam.tar.gz
        - tar -xzf /tmp/gleam.tar.gz -C /usr/local/bin gleam
        - rm -f /tmp/gleam.tar.gz
        - install -d -m 0755 /usr/local/lib/aonohako/gleam-home
        - mkdir -p /tmp/gleam-warmup/src
        - printf '%s\n' 'name = "warmup"' 'version = "1.0.0"' '' '[dependencies]' 'gleam_stdlib = "~> 0.44"' > /tmp/gleam-warmup/gleam.toml
        - printf '%s\n' 'import gleam/io' 'pub fn main() {' '  io.println("ok")' '}' > /tmp/gleam-warmup/src/main.gleam
        - (cd /tmp/gleam-warmup && env HOME=/usr/local/lib/aonohako/gleam-home gleam build)
        - cp /tmp/gleam-warmup/manifest.toml /usr/local/lib/aonohako/gleam-manifest.toml
        - mkdir -p /usr/local/lib/aonohako/gleam-packages
        - cp -a /tmp/gleam-warmup/build/packages/. /usr/local/lib/aonohako/gleam-packages/
        - rm -rf /tmp/gleam-warmup
        - chmod -R a+rX /usr/local/lib/aonohako/gleam-home /usr/local/lib/aonohako/gleam-manifest.toml /usr/local/lib/aonohako/gleam-packages
    smoke:
      command:
        - bash
        - -lc
        - |
          workdir="$(mktemp -d)"
          trap 'rm -rf "${workdir}"' EXIT
          cd "${workdir}"
          mkdir -p src
          printf '%s\n' 'name = "smoke"' 'version = "1.0.0"' '' '[dependencies]' 'gleam_stdlib = "~> 0.44"' > gleam.toml
          printf '%s\n' 'import gleam/io' 'pub fn main() {' '  io.println("ok")' '}' > src/main.gleam
          cp /usr/local/lib/aonohako/gleam-manifest.toml manifest.toml
          mkdir -p build/packages
          cp -a /usr/local/lib/aonohako/gleam-packages/. build/packages/
          env HOME=/usr/local/lib/aonohako/gleam-home gleam build
          aonohako-gleam-run . | grep '^ok$'

  cuda-ocelot:
    install:
      apt:
        - build-essential
        - bison
        - clang-15
        - cmake
        - flex
        - git
        - libboost-all-dev
        - libfl-dev
        - libglew-dev
        - libzstd-dev
        - llvm-15
        - llvm-15-dev
        - ninja-build
      script:
        - export GPUOCELOT_COMMIT=b16039dc940dc6bc4ea0a98380495769ff35ed99
        - git clone --filter=blob:none --sparse https://github.com/gpuocelot/gpuocelot /opt/gpuocelot-src
        - cd /opt/gpuocelot-src && git checkout "${GPUOCELOT_COMMIT}" && git sparse-checkout set --no-cone /ocelot /.gitmodules
        - >-
          cd /opt/gpuocelot-src && git submodule update --init --recursive
          ocelot/ThirdParty/hydrazine
          ocelot/ThirdParty/res_embed
          ocelot/ThirdParty/cuda-fatbin-decompression
        - cmake -S /opt/gpuocelot-src/ocelot -B /opt/gpuocelot-src/build -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt/gpuocelot
        - cmake --build /opt/gpuocelot-src/build --target install
        - ln -sfn /usr/local/cuda/bin/nvcc /usr/local/bin/nvcc
        - install -d -m 0755 /usr/local/share/aonohako/ocelot
        - >-
          printf '%s\n' 'executive: {' '  devices: ["emulated"]' '  preferredISA: "nvidia"' '}'
          'cuda: {' '  implementation: "cuda"' '}'
          > /usr/local/share/aonohako/ocelot/configure.ocelot
        - rm -rf /opt/gpuocelot-src
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.cu <<'CUDA'
          #include <cstdio>
          int main() {
            std::puts("ok");
            return 0;
          }
          CUDA
          aonohako-cuda-ocelot-build Main.cu Main
          aonohako-cuda-ocelot-run ./Main | grep '^ok$'

  carbon:
    install:
      apt:
        - curl
      script:
        - export CARBON_VERSION=0.0.0-0.nightly.2026.05.02
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/carbon-language/carbon-lang/releases/download/v${CARBON_VERSION}/carbon_toolchain-${CARBON_VERSION}.tar.gz" -o /tmp/carbon.tar.gz
        - mkdir -p /opt/carbon
        - tar -xzf /tmp/carbon.tar.gz -C /opt/carbon --strip-components=1
        - ln -sfn /opt/carbon/bin/carbon /usr/local/bin/carbon
        - rm -f /tmp/carbon.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'fn Run() {}' > Main.carbon
          carbon compile --phase=check Main.carbon >/dev/null

  graphql:
    install:
      apt:
        - python3
        - python3-pip
      pip:
        - graphql-core==3.2.6
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'query { ok }' > Main.graphql
          aonohako-graphql-run Main.graphql | grep '{"data":{"ok":"ok"}}'

  fstar:
    install:
      apt:
        - curl
        - tar
        - wget
      script:
        - export FSTAR_VERSION=2026.06.28
        - export FSTAR_URL="https://github.com/FStarLang/FStar/releases/download/v${FSTAR_VERSION}/fstar-v${FSTAR_VERSION}-Linux-x86_64.tar.gz"
        - curl --retry 6 --retry-all-errors --retry-delay 2 -fL "$FSTAR_URL" -o /tmp/fstar.tar.gz || wget --tries=6 --waitretry=2 -O /tmp/fstar.tar.gz "$FSTAR_URL"
        - rm -rf /opt/fstar "/opt/fstar-${FSTAR_VERSION}"
        - tar -xzf /tmp/fstar.tar.gz -C /opt
        - mv /opt/fstar "/opt/fstar-${FSTAR_VERSION}"
        - ln -sfn "/opt/fstar-${FSTAR_VERSION}" /opt/fstar
        - ln -sfn /opt/fstar/bin/fstar.exe /usr/local/bin/fstar.exe
        - ln -sfn /opt/fstar/bin/fstar.exe /usr/local/bin/fstar
        - rm -f /tmp/fstar.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.fst <<'FSTAR'
          module Main
          let ok () : Lemma (1 + 1 == 2) = ()
          FSTAR
          fstar.exe Main.fst

  alloy:
    install:
      apt:
        - curl
        - default-jre-headless
        - python3
        - wget
      script:
        - export ALLOY_VERSION=6.2.0
        - export ALLOY_URL="https://github.com/AlloyTools/org.alloytools.alloy/releases/download/v${ALLOY_VERSION}/org.alloytools.alloy.dist.jar"
        - install -d -m 0755 /usr/local/lib/aonohako
        - curl --retry 6 --retry-all-errors --retry-delay 2 -fL "$ALLOY_URL" -o /usr/local/lib/aonohako/alloy.jar || wget --tries=6 --waitretry=2 -O /usr/local/lib/aonohako/alloy.jar "$ALLOY_URL"
        - chmod 0644 /usr/local/lib/aonohako/alloy.jar
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.als <<'ALLOY'
          sig A {}
          assert ok { all a: A | a = a }
          check ok for 3
          run { some A } for 1
          ALLOY
          aonohako-alloy-check Main.als
          cat > Broken.als <<'ALLOY'
          sig A {}
          assert bad { no A }
          check bad for exactly 1 A
          ALLOY
          if aonohako-alloy-check Broken.als >/dev/null 2>&1; then exit 1; fi

  acl2:
    install:
      apt:
        - acl2
        - bash
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.lisp <<'ACL2'
          (in-package "ACL2")
          (defthm plus-zero-right
            (implies (integerp x)
                     (equal (+ x 0) x)))
          ACL2
          aonohako-acl2-check Main.lisp
          cat > Broken.lisp <<'ACL2'
          (in-package "ACL2")
          (defthm bad (equal (+ 1 1) 2))
          ACL2
          if aonohako-acl2-check Broken.lisp >/dev/null 2>&1; then exit 1; fi

  kframework:
    install:
      apt:
        - curl
        - default-jre-headless
        - python3
      script:
        - export KFRAMEWORK_VERSION=7.1.337
        - export KFRAMEWORK_URL="https://github.com/runtimeverification/k/releases/download/v${KFRAMEWORK_VERSION}/kframework_${KFRAMEWORK_VERSION}_amd64_ubuntu_noble.deb"
        - curl --retry 6 --retry-all-errors --retry-delay 2 -fL "$KFRAMEWORK_URL" -o /tmp/kframework.deb
        - apt-get update
        - apt-get install -y --no-install-recommends /tmp/kframework.deb
        - rm -f /tmp/kframework.deb
        - rm -rf /var/lib/apt/lists/*
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.k <<'K'
          module MAIN
            imports INT
            syntax Exp ::= Int
          endmodule
          K
          aonohako-kframework-check Main.k

  lean4:
    install:
      apt:
        - curl
        - unzip
        - wget
      script:
        - export LEAN_VERSION=4.29.1
        - export LEAN_URL="https://github.com/leanprover/lean4/releases/download/v${LEAN_VERSION}/lean-${LEAN_VERSION}-linux.zip"
        - curl --retry 6 --retry-all-errors --retry-delay 2 -fL "$LEAN_URL" -o /tmp/lean.zip || wget --tries=6 --waitretry=2 -O /tmp/lean.zip "$LEAN_URL"
        - rm -rf /opt/lean
        - unzip -q /tmp/lean.zip -d /opt
        - mv "/opt/lean-${LEAN_VERSION}-linux" /opt/lean
        - ln -sfn /opt/lean/bin/lean /usr/local/bin/lean
        - ln -sfn /opt/lean/bin/lake /usr/local/bin/lake
        - rm -f /tmp/lean.zip
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'theorem ok : True := by trivial' > Main.lean
          lean Main.lean

  agda:
    install:
      apt:
        - agda
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.agda <<'AGDA'
          module Main where
          data Unit : Set where
            tt : Unit
          ok : Unit
          ok = tt
          AGDA
          agda Main.agda >/dev/null

  dafny:
    install:
      apt:
        - curl
        - wget
        - unzip
      script:
        - export DAFNY_VERSION=4.11.0
        - export DAFNY_URL="https://github.com/dafny-lang/dafny/releases/download/v${DAFNY_VERSION}/dafny-${DAFNY_VERSION}-x64-ubuntu-22.04.zip"
        - curl --retry 6 --retry-all-errors --retry-delay 2 -fL "$DAFNY_URL" -o /tmp/dafny.zip || wget --tries=6 --waitretry=2 -O /tmp/dafny.zip "$DAFNY_URL"
        - rm -rf /opt/dafny
        - unzip -q /tmp/dafny.zip -d /opt/dafny
        - ln -sfn /opt/dafny/dafny/dafny /usr/local/bin/dafny
        - rm -f /tmp/dafny.zip
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'method Main() ensures true {' '}' > Main.dfy
          env DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1 DOTNET_PROCESSOR_COUNT=1 COMPlus_ThreadPool_ForceMinWorkerThreads=1 dafny verify --cores 1 Main.dfy >/dev/null

  tla:
    install:
      apt:
        - curl
        - default-jre-headless
        - wget
      script:
        - export TLA_VERSION=1.7.4
        - export TLA_URL="https://github.com/tlaplus/tlaplus/releases/download/v${TLA_VERSION}/tla2tools.jar"
        - install -d -m 0755 /usr/local/lib/aonohako
        - curl --retry 6 --retry-all-errors --retry-delay 2 -fL "$TLA_URL" -o /usr/local/lib/aonohako/tla2tools.jar || wget --tries=6 --waitretry=2 -O /usr/local/lib/aonohako/tla2tools.jar "$TLA_URL"
        - chmod 0644 /usr/local/lib/aonohako/tla2tools.jar
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.tla <<'TLA'
          ---- MODULE Main ----
          VARIABLE x
          Init == x = 0
          Next == x' = x
          Spec == Init /\ [][Next]_x
          ====
          TLA
          printf '%s\n' 'SPECIFICATION Spec' > Main.cfg
          aonohako-tla-run Main.tla

  why3:
    install:
      apt:
        - why3
        - z3
      script:
        - install -d -m 0755 /usr/local/lib/aonohako/why3-home
        - env HOME=/usr/local/lib/aonohako/why3-home why3 config detect
        - chmod -R a+rX /usr/local/lib/aonohako/why3-home
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'theory Main' '  goal G: true' 'end' > Main.mlw
          aonohako-why3-prove Main.mlw

  isabelle:
    install:
      apt:
        - curl
        - fontconfig
        - perl
        - tar
        - wget
      script:
        - export ISABELLE_VERSION=Isabelle2025-2
        - export ISABELLE_SHA256=a20a507bc7c1270d8be96a9f3fbec06345387789d2dc2c4d3df6260d47bfb33c
        - >-
          downloaded=0;
          for url in
          "https://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/${ISABELLE_VERSION}_linux.tar.gz"
          "https://isabelle.in.tum.de/website-Isabelle2025-2/dist/${ISABELLE_VERSION}_linux.tar.gz";
          do
            rm -f /tmp/isabelle.tar.gz;
            if curl --retry 8 --retry-all-errors --retry-delay 3 --connect-timeout 20 -fL "$url" -o /tmp/isabelle.tar.gz ||
               wget --tries=8 --waitretry=3 --timeout=20 -O /tmp/isabelle.tar.gz "$url"; then
              printf '%s  %s\n' "$ISABELLE_SHA256" /tmp/isabelle.tar.gz | sha256sum -c -;
              downloaded=1;
              break;
            fi;
          done;
          test "$downloaded" = 1
        - tar -xzf /tmp/isabelle.tar.gz -C /opt
        - ln -sfn "/opt/${ISABELLE_VERSION}/bin/isabelle" /usr/local/bin/isabelle
        - sed -i 's/val channel = System_Channel()/val channel = System_Channel(unix_domain = true)/' "/opt/${ISABELLE_VERSION}/src/Pure/System/isabelle_process.scala"
        - sed -i '/isabelle.Bash[$]Handler/d' "/opt/${ISABELLE_VERSION}/etc/build.props"
        - env JAVA_TOOL_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC -XX:ReservedCodeCacheSize=32m -XX:MaxMetaspaceSize=192m -XX:CompressedClassSpaceSize=64m' ISABELLE_JAVA_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC' ISABELLE_TOOL_JAVA_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC' ISABELLE_JAVA_SYSTEM_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC' isabelle scala_build
        - rm -f /tmp/isabelle.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > ROOT <<'ROOT'
          session Aonohako = HOL +
            theories Aonohako_Main
          ROOT
          cat > Aonohako_Main.thy <<'THY'
          theory Aonohako_Main
            imports Main
          begin
          theorem ok: True by simp
          end
          THY
          env JAVA_TOOL_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC -XX:ReservedCodeCacheSize=32m -XX:MaxMetaspaceSize=192m -XX:CompressedClassSpaceSize=64m' ISABELLE_JAVA_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC' ISABELLE_TOOL_JAVA_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC' ISABELLE_JAVA_SYSTEM_OPTIONS='-Xms64m -Xmx1024m -Xss1m -XX:+UseSerialGC' isabelle process_theories -o naproche_server=false -D . >/dev/null

  vb6:
    install:
      apt:
        - ruby
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'Sub Main()' 'Print "ok"' 'End Sub' > Main.bas
          aonohako-vb6-run Main.bas | grep '^ok$'

  freebasic:
    install:
      shared:
        - freebasic
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'print "ok"' > Main.bas
          fbc -x Main Main.bas
          ./Main | grep '^ok$'

  classic-basic:
    install:
      shared:
        - freebasic
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'PRINT "ok"' > Main.bas
          fbc -lang qb -x Main Main.bas
          ./Main | grep '^ok$'

  qbasic:
    install:
      shared:
        - freebasic
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'PRINT "ok"' > Main.bas
          fbc -lang qb -x Main Main.bas
          ./Main | grep '^ok$'

  smalltalk:
    install:
      apt:
        - build-essential
        - curl
        - file
        - gawk
        - libffi-dev
        - libreadline-dev
        - libsigsegv-dev
        - zip
      script:
        - export GST_VERSION=3.2.5
        - |
          for url in \
            "https://mirrors.kernel.org/gnu/smalltalk/smalltalk-${GST_VERSION}.tar.gz" \
            "https://ftp.gnu.org/gnu/smalltalk/smalltalk-${GST_VERSION}.tar.gz"; do
            if curl --retry 3 --retry-delay 2 --retry-connrefused --connect-timeout 20 --max-time 180 -fsSL "${url}" -o /tmp/smalltalk.tar.gz; then
              break
            fi
            rm -f /tmp/smalltalk.tar.gz
          done
          test -s /tmp/smalltalk.tar.gz
        - tar -xzf /tmp/smalltalk.tar.gz -C /tmp
        - sed -i 's/const char \*inbuf;/char *inbuf;/' "/tmp/smalltalk-${GST_VERSION}/packages/iconv/iconv.c"
        - (cd "/tmp/smalltalk-${GST_VERSION}" && CC=/usr/bin/gcc-14 ./configure --prefix=/usr/local && make -j1 && make install)
        - rm -rf "/tmp/smalltalk-${GST_VERSION}" /tmp/smalltalk.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' "'ok' displayNl" > Main.st
          gst -q Main.st | grep '^ok$'

  golfscript:
    install:
      apt:
        - ruby
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s' '"ok\n"' > Main.gs
          ruby /usr/local/lib/aonohako/golfscript_sandboxed.rb Main.gs | grep '^ok$'

  mojo:
    install:
      apt:
        - curl
        - python3
        - python3-venv
      script:
        - python3 -m venv /opt/mojo-venv
        - /opt/mojo-venv/bin/pip install --no-cache-dir mojo==1.0.0
        - ln -sfn /opt/mojo-venv/bin/mojo /usr/local/bin/mojo
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'def main():' '    print("ok")' > Main.mojo
          mojo build Main.mojo -o Main
          ./Main | grep '^ok$'

  deno:
    install:
      apt:
        - curl
        - unzip
      script:
        - export DENO_VERSION=2.7.14
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/denoland/deno/releases/download/v${DENO_VERSION}/deno-x86_64-unknown-linux-gnu.zip" -o /tmp/deno.zip
        - unzip -q /tmp/deno.zip -d /usr/local/bin
        - chmod 0755 /usr/local/bin/deno
        - rm -f /tmp/deno.zip
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'console.log("ok");' > Main.ts
          deno check --v8-flags=--max-old-space-size=512 Main.ts
          deno run --no-prompt --v8-flags=--max-old-space-size=128 Main.ts | grep '^ok$'

  kotlin-jvm:
    install:
      apt:
        - curl
        - default-jdk-headless
        - unzip
      script:
        - export KOTLIN_JVM_VERSION=2.3.21
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/JetBrains/kotlin/releases/download/v${KOTLIN_JVM_VERSION}/kotlin-compiler-${KOTLIN_JVM_VERSION}.zip" -o /tmp/kotlin-compiler.zip
        - unzip -q /tmp/kotlin-compiler.zip -d /opt
        - ln -sfn /opt/kotlinc/bin/kotlinc /usr/local/bin/kotlinc
        - rm -f /tmp/kotlin-compiler.zip
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 'final class Helper {' '  static String value() {' '    return "ok";' '  }' '}' > Helper.java
          printf '%s\n' 'fun main() {' '  println(Helper.value())' '}' > Main.kt
          kotlinc -jvm-target 1.8 Main.kt Helper.java -include-runtime -d Main.jar
          javac --release 8 -cp Main.jar Helper.java
          jar uf Main.jar Helper.class
          java -Xms64m -Xmx128m -Xss1m -XX:+UseSerialGC -XX:MaxDirectMemorySize=16m -XX:MaxMetaspaceSize=64m -XX:CompressedClassSpaceSize=64m -XX:ReservedCodeCacheSize=32m -DONLINE_JUDGE=1 -jar Main.jar | grep '^ok$'

  duckdb:
    install:
      apt:
        - curl
        - unzip
      script:
        - export DUCKDB_VERSION=1.5.2
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/duckdb/duckdb/releases/download/v${DUCKDB_VERSION}/duckdb_cli-linux-amd64.zip" -o /tmp/duckdb.zip
        - unzip -q /tmp/duckdb.zip -d /usr/local/bin
        - chmod 0755 /usr/local/bin/duckdb
        - rm -f /tmp/duckdb.zip
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' "create table t(v varchar);" "insert into t values ('ok');" > setup.sql
          printf '%s\n' "select v from t;" > Main.sql
          aonohako-duckdb-run Main.sql < setup.sql | grep '^ok$'

  bqn:
    install:
      apt:
        - build-essential
        - git
        - libffi-dev
      script:
        - export CBQN_COMMIT=d56147be877693eaed351745782c258bd7424de7
        - git clone --recursive https://github.com/dzaima/CBQN /opt/cbqn
        - cd /opt/cbqn && git checkout "${CBQN_COMMIT}" && git submodule update --init --recursive && make REPLXX=0
        - install -m 0755 /opt/cbqn/BQN /usr/local/bin/bqn
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' '•Out "ok"' > Main.bqn
          bqn Main.bqn | grep '^ok$'

  apl:
    install:
      shared:
        - node24
      npm:
        - kanapl@0.0.0
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' "⎕←'ok'" > Main.apl
          node --disable-wasm-trap-handler --max-old-space-size=64 --max-semi-space-size=1 --stack-size=2048 /usr/local/bin/apl --script -f Main.apl | grep '^ok$'

  j:
    install:
      apt:
        - ca-certificates
        - curl
        - unzip
      script:
        - export J_VERSION=963
        - export J_SOURCE_COMMIT=a9728936d7bd7743024db26a8fcb72e5f2fcadac
        - export J_ENGINE_SHA256=ff5b91383265d27e2b9edb4c934ba1b642784417196ba6c2b09a2661c2a173d1
        - export J_SOURCE_SHA256=ce9dfef9911f330821b3a26031e35c5e3baaaa8a54d6c919608134a121e5b5a6
        - mkdir -p /tmp/j-engine /tmp/j-source
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/jsoftware/jsource/releases/download/build96/l64.zip" -o /tmp/j-l64.zip
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/jsoftware/jsource/archive/${J_SOURCE_COMMIT}.tar.gz" -o /tmp/j-source.tar.gz
        - echo "${J_ENGINE_SHA256}  /tmp/j-l64.zip" | sha256sum -c -
        - echo "${J_SOURCE_SHA256}  /tmp/j-source.tar.gz" | sha256sum -c -
        - unzip -q /tmp/j-l64.zip -d /tmp/j-engine
        - tar -xzf /tmp/j-source.tar.gz -C /tmp/j-source --strip-components=1
        - mkdir -p "/opt/j${J_VERSION}"
        - cp -a /tmp/j-engine/j64 "/opt/j${J_VERSION}/bin"
        - cp -a /tmp/j-source/jlibrary/. "/opt/j${J_VERSION}/"
        - chmod 0755 "/opt/j${J_VERSION}/bin/jconsole"
        - ln -sfn "/opt/j${J_VERSION}/bin/jconsole" /usr/local/bin/aonohako-j
        - rm -rf /tmp/j-engine /tmp/j-source /tmp/j-l64.zip /tmp/j-source.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' "echo 'ok'" 'exit 0' > Main.ijs
          aonohako-j Main.ijs | grep '^ok$'

  uiua:
    install:
      apt:
        - curl
        - unzip
      script:
        - export UIUA_VERSION=0.18.1
        - export UIUA_SHA256=83ce782e1c843937fee1aae1dc7db0480bed425a88fe0c18109df7a0d1970470
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/uiua-lang/uiua/releases/download/${UIUA_VERSION}/uiua-bin-x86_64-unknown-linux-gnu-no-audio.zip" -o /tmp/uiua.zip
        - echo "${UIUA_SHA256}  /tmp/uiua.zip" | sha256sum -c -
        - unzip -q /tmp/uiua.zip -d /usr/local/bin
        - chmod 0755 /usr/local/bin/uiua
        - rm -f /tmp/uiua.zip
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' '&p "ok"' > Main.ua
          uiua run Main.ua --no-format | grep '^ok$'

  janet:
    install:
      apt:
        - curl
      script:
        - export JANET_VERSION=1.41.2
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/janet-lang/janet/releases/download/v${JANET_VERSION}/janet-v${JANET_VERSION}-linux-x64.tar.gz" -o /tmp/janet.tar.gz
        - mkdir -p /opt/janet
        - tar -xzf /tmp/janet.tar.gz -C /opt/janet --strip-components=1
        - export JANET_BIN="$(find /opt/janet -type f -name janet | head -n1)"
        - test -n "${JANET_BIN}" && ln -sfn "${JANET_BIN}" /usr/local/bin/janet
        - rm -f /tmp/janet.tar.gz
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' '(print "ok")' > Main.janet
          janet Main.janet | grep '^ok$'

  sed:
    install:
      apt:
        - sed
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' 's/^/ok/' > Main.sed
          printf '%s\n' '' | sed -f Main.sed | grep '^ok$'

  bc:
    install:
      apt:
        - bc
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' '1 + 1' > Main.bc
          bc -q Main.bc | grep '^2$'

  forth:
    install:
      shared:
        - gforth
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' '." ok" cr' > Main.fs
          gforth Main.fs -e bye | grep '^ok$'

  gforth:
    install:
      shared:
        - gforth
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' '." ok" cr' > Main.fs
          gforth Main.fs -e bye | grep '^ok$'

  uhmlang:
    install:
      apt:
        - git
      script:
        - ln -sfn /usr/local/go/bin/go /usr/local/bin/go
        - ln -sfn /usr/local/go/bin/gofmt /usr/local/bin/gofmt
        - git clone --depth=1 https://github.com/rycont/umjunsik-lang.git /tmp/umjunsik-lang
        # Upstream uses Scanln for 식?, which cannot consume BOJ-style same-line integer input like "5 1".
        - sed -i 's/fmt.Scanln(&integer)/fmt.Scan(\&integer)/' /tmp/umjunsik-lang/umjunsik-lang-go/eval/eval.go
        - grep -q 'fmt.Scan(&integer)' /tmp/umjunsik-lang/umjunsik-lang-go/eval/eval.go
        - cd /tmp/umjunsik-lang/umjunsik-lang-go && env -u GOROOT GOENV=off go build -o /usr/local/bin/umjunsik-lang-go .
        - ln -sfn /usr/local/bin/umjunsik-lang-go /usr/bin/umjunsik-lang-go
        - rm -rf /tmp/umjunsik-lang
    smoke:
      command:
        - bash
        - -lc
        - |
          printf '%s\n' '어떻게' '식........... ........ㅋ' '이 사람이름이냐ㅋㅋ' > Main.uhm
          /usr/bin/umjunsik-lang-go Main.uhm | grep '^X$'
          printf '%s\n' '어떻게' '' '엄식?' '어엄식?' '' '동탄어?준... ....' '' '엄어,' '어엄어어.' '' '준.. ...' '식어어!' '' '이 사람이름이냐ㅋㅋ' > Main.uhm
          printf '5 1\n' | /usr/bin/umjunsik-lang-go Main.uhm | grep '^6$'

  zerolang:
    install:
      apt:
        - curl
      script:
        - export ZERO_VERSION=0.3.4
        - export ZERO_LINUX_X64_SHA256=84a3c79d482260ee15660a49fc6b904afc927a230d05a4263039dd4dd1360e87
        - curl --retry 5 --retry-delay 2 --retry-connrefused -fsSL "https://github.com/vercel-labs/zerolang/releases/download/v${ZERO_VERSION}/zero-linux-x64" -o /tmp/zero
        - printf '%s  %s\n' "${ZERO_LINUX_X64_SHA256}" /tmp/zero | sha256sum -c -
        - install -m 0755 /tmp/zero /usr/local/bin/zero
        - rm -f /tmp/zero
        - zero --version
    smoke:
      command:
        - bash
        - -lc
        - |
          cat > Main.0 <<'ZERO'
          pub fn main(world: World) -> Void raises {
            check world.out.write("ok\n")
          }
          ZERO
          export ZERO_CACHE_DIR=/tmp/zerolang-cache
          zero import --out Main.graph Main.0
          zero check Main.graph
          zero build --release release-fast --out Main Main.graph
          ./Main | grep '^ok$'
          printf '%s\n' 'pub fn main(' > Broken.0
          if zero import --out Broken.graph Broken.0 >/dev/null 2>&1; then exit 1; fi

profiles:
  type-a:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: &gcc16_profile
      script:
        - echo 'deb http://deb.debian.org/debian sid main' > /etc/apt/sources.list.d/aonohako-gcc16-sid.list
        - apt-get update
        - DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends -t sid gcc-16 g++-16
        - apt-get clean
        - rm -rf /var/lib/apt/lists/*
        - ln -sfn /usr/bin/gcc-16 /usr/local/bin/gcc
        - ln -sfn /usr/bin/g++-16 /usr/local/bin/g++
        - ln -sfn /usr/bin/gcc-16 /usr/local/bin/cc
        - ln -sfn /usr/bin/g++-16 /usr/local/bin/c++
    languages:
      - aheui
      - apecode
      - apl
      - awk
      - bc
      - befunge
      - bf
      - bqn
      - elixir
      - erlang
      - forth
      - gforth
      - gleam
      - golfscript
      - haskell
      - idris2
      - j
      - janet
      - lisp
      - lolcode
      - lua
      - malbolge
      - mercury
      - ocaml
      - perl
      - php
      - picolisp
      - plain
      - prolog
      - pypy
      - r
      - raku
      - racket
      - ruby
      - scheme
      - sed
      - sml
      - smalltalk
      - sqlite
      - tcl
      - uiua
      - wasm
      - whitespace
  type-b:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - clojure
      - coffeescript
      - deno
      - elm
      - graphql
      - groovy
      - haxe
      - java
      - javascript
      - purescript
      - rescript
      - scala
      - typescript
  type-c:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - ada
      - asm
      - c3
      - classic-basic
      - cobol
      - crystal
      - cython
      - d
      - delphi
      - freebasic
      - fortran
      - go
      - gnucobol
      - hare
      - mojo
      - nasm
      - nim
      - objective-c
      - objective-cpp
      - objectpascal
      - odin
      - pascal
      - qbasic
      - rust
      - vala
      - vlang
      - zerolang
      - zig
  type-d:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - kotlin
      - kotlin-jvm
  type-e:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - csharp
      - fsharp
      - vbnet
  type-f:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - uhmlang
  type-g:
    base_image: julia:1.11.5-bookworm@sha256:be7093a80d030bb8ec7cdc093aabb3428da995b466dbf6c0b472380107472316
    install: *gcc16_profile
    languages:
      - julia
  type-h:
    base_image: swift:6.2.1-bookworm@sha256:73f569f5536fe3c9ad5109eb4622c5560af7424d55304955190e5fbccc047b86
    install: *gcc16_profile
    languages:
      - swift
  type-i:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - c
      - cpp
      - plain
      - python
      - pypy
      - java
  type-j:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    languages:
      - agda
      - coq
      - rocq
      - tla
      - why3
  type-k:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - dart
  type-l:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - python
  type-m:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - duckdb
      - gdl
      - octave
  type-n:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - systemverilog
      - verilog
      - vhdl
  type-o:
    base_image: nvidia/cuda:11.8.0-devel-ubuntu22.04@sha256:94fd755736cb58979173d491504f0b573247b1745250249415b07fefc738e41f
    languages:
      - cuda-ocelot
  type-p:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    install: *gcc16_profile
    languages:
      - carbon
      - vb6
  type-q:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    languages:
      - dafny
  type-r:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    languages:
      - isabelle
  type-s:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    languages:
      - lean4
  type-t:
    base_image: debian:trixie-slim@sha256:28de0877c2189802884ccd20f15ee41c203573bd87bb6b883f5f46362d24c5c2
    languages:
      - acl2
      - alloy
      - fstar
  type-u:
    base_image: ubuntu:noble@sha256:786a8b558f7be160c6c8c4a54f9a57274f3b4fb1491cf65146521ae77ff1dc54
    languages:
      - kframework