open-steamgate

open-steamgate

An ABAP application server you can clone.

Part of the steampunk family: vsp (ADT ↔ MCP), abapiti (TypeScript and WASM to ABAP), open-rfc-go (RFC) and open-diag-go (SAP GUI DIAG).

TL;DR — run it

Each release also carries sqlite.yml, duckdb.yml and postgres.yml; start one with docker compose -f sqlite.yml up -d. ./osd doctor checks a downloaded binary.

🎉 gogen compiles itself (self-hosting step 4, 2026-10-20)

gogen, the ABAP-to-Go compiler in this tree, is written in JavaScript. abapiti compiled gogen itself into Go, and that Go-built gogen emits the same Go as gogen on Node, byte for byte, for the reference class. The output builds and passes its unit test:

step4: build=ok run=ok cmp=equal ref=b90648781967b2cf out=b90648781967b2cf
PASS: ZCL_GOGEN_T_RUNTIME/LTCL_RUNTIME/ELAPSED

Measured on 0b925177 in main with abapiti 3115e569. About twenty full runs, about fifteen fixes on each side, Node output unchanged by every one: the story and both SHAs. The trap-by-trap log before it is in docs/self-hosting-step4-traps.md.

What it is

open-steamgate (OSD) cross-compiles real ABAP — _MPC_EXT / _DPC_EXT Gateway classes, CDS views, AMDP methods, reports — and runs it against a local database. It serves OData to Fiori Elements, lets Eclipse edit it over ADT, and answers SAP GUI on the DIAG port. No SAP system is attached.

It is the layer under an ERP, not an ERP. The language runtime, the dictionary, Open SQL, the ICF service tree, the OData gateway, CDS, AMDP, LUW, screens, jobs and daemons are all here. There is no business application: no finance, no logistics. Everything runs as a subset: of the language, of the dictionary, and of Gateway (classic code-based SEGW).

Everything is a file. The ABAP is a repository, the tables are abapGit TABU JSON, a build is an immutable generation addressed by the hash of its inputs, and the database sits behind an eleven-method seam: sql.js, SQLite, DuckDB, PostgreSQL or HANA. So a whole system can be copied, branched, compared and thrown away.

The name: vsp (vibing-steampunk) → steamgate. Gate is the SAP Gateway, the /IWBEP/ framework whose runtime this project reimplements.

The ways to run it, in a sentence each

• Browser. The transpiled ABAP, the OData runtime and SQLite run in a service worker on your machine; no server answers anything.
• Docker. ghcr.io/oisee/open-steamgate, tags showcase-draft (with the demo packs) and draft (core), multi-arch amd64 and arm64. The arm64 image also runs on a Raspberry Pi 4 (docs/spin.md).
• Binary. One self-contained Bun executable per platform. It copies its system into your user data directory on first start and layers your own folders over it with osd up --layer <folder>.
• VS Code. The OSD tree, F8 data preview, ABAP Unit in the Test Explorer, debugging, and a .http CodeLens that finds the DPC method behind a request.

For warm local development (OSD_WARM=1 STG_DEV=1 npm start), run npm run transpiler:pin after npm ci. It builds the libs.lock.json pin in $HOME/.cache/osd/transpiler-<ref> and links transpiler, CLI, runtime and core; a verified build is reused. Override the persistent location with TRANSPILER; temporary directories and session scratchpads are refused. Startup and osd doctor print a prominent install hint if warm capabilities are missing. See warm setup.

The launchpad in the browser build:

The first visit installs the worker; after that the app works offline. Private windows usually refuse service workers.

What it looks like

Every pixel below is served by transpiled ABAP over SQLite. SAPUI5 1.120 is loaded from SAP's CDN, unchanged.

node scripts/capture-docs-shots.mjs takes these pictures while npm start is running.

Where it stands, 2026-09-30

0.3 beta was released on 2026-09-29 (vscode-v0.2.1307); 0.4 is in progress. AGENDA.md records every decision, docs/backlog/ is the open list, and ANORMALIES.md records every place the runtime differs from SAP, written down before any workaround.

ABAP as a language for command-line tools

gogen compiles ABAP to Go (OSGo; building needs Go 1.26). Two hosts come out of it.

A report becomes a native command. osabap takes a classic executable report and builds one self-contained binary with no server, no database and no SAP system (npm run osgb -- <report> is the same command: osabap is the compiler, OSGB the binary it makes). The compiler itself runs on Node; the binary does not. The selection screen is the command-line contract:

node tools/gogen/osabap.mjs tools/gogen/apps/hello/zhello.prog.abap   # -> tools/gogen/.out/osabap
tools/gogen/.out/osabap Alice                        # parameters in declaration order
tools/gogen/.out/osabap --name Alice --loud --s-tag one --s-tag two  # a repeated select-option = I/EQ rows
tools/gogen/.out/osabap -params @arguments.json     # or all of it as JSON
tools/gogen/.out/osabap                              # no arguments, a terminal: the selection screen as a TUI
tools/gogen/.out/osabap -sapgui                     # the same screen to a real SAP GUI over DIAG, on 127.0.0.1
GOOS=windows GOARCH=arm64 node tools/gogen/osabap.mjs report.prog.abap   # cross-compiles

The usual lifecycle runs: INITIALIZATION, the selection-screen events, START-OF-SELECTION, WRITE to stdout. CL_GUI_FRONTEND_SERVICES maps to the local file system. OPEN DATASET works inside the roots you allow (-allow-read ./in -allow-write ./out). Build with --read-params P_FILE,P_CONFIG to grant reads to the files or directories the user supplies, or --read-lists P_DEPS to also grant the paths listed in that file (relative to its directory). Supplying a list means the user vouches for every path in it, including absolute and ../ entries; a list the report wrote earlier is still the user's choice to pass. The host grants these reads before ABAP runs; -no-default-reads disables them, and writes still require explicit permission. A report with tables of its own (their .tabl.xml beside the report) keeps its rows in the SQLite file -db notes.db names, created with those tables when missing; 12 of the 18 Open SQL forms of tools/gogen/apps/sql-corpus compile so far. The samples are in tools/gogen/apps/, and the details are in docs/osabap-native.md.

The whole system in Go. node tools/gogen/osgo.mjs builds tools/gogen/.out/osgo, the complete OSD (ICF, Gateway, the apps, SQLite) as one Go binary. The same ABAP Unit tests run on Node and on Go and are compared method by method; closing the gap is the work before 0.4.

Generated classes in CI. The same folder of *.clas.abap and *.clas.testclasses.abap can run on either runtime:

npm run osgo:unit -- ./generated --json --class ZCL_EXAMPLE
npm run osgjs:unit -- ./generated --json --class ZCL_EXAMPLE

Both commands read the immediate directory, stage missing class metadata in a temporary folder, preserve existing .clas.xml, reject source lines longer than 255 characters with file:line, and report overrides on stderr and in JSON. --class accepts multiple owner names; omit it to run all owners in the folder. They work from any cwd when invoked by the checkout's absolute script path. JSON contains rows (class, testclass, method, status, message), totals (success, failure, not_compiled, error, tests) and overrides. Exit codes are 0 for at least one test and all SUCCESS, 1 for assertion FAILURE, 2 for NOT_COMPILED/ERROR/SKIPPED, and 3 when there are no tests.

The JS command requires installed Node dependencies and synced libraries. It copies the configured checkout layers into a disposable checkout, excluding all content packs (including OSD_PACKS), runs the generators and transpiles the whole tree (roughly 20 seconds for transpilation), then runs ABAP Unit only for the selected owners, including class and instance lifecycle hooks. This command still builds the whole tree; the local warm path can use the pinned transpiler's only option. For large generated folders, use Node with a larger heap and a private SQLite file instead of in-memory sql.js:

NODE_OPTIONS=--max-old-space-size=12288 npm run osgjs:unit -- ./generated --db file --json

--db sqlite (the default) uses sql.js; --db file creates its database in the invocation's staging directory and removes it on completion. Inherited STG_DB_PATH cannot select another database. NODE_OPTIONS reaches the scanner, transpiler, generators and Unit child; choose a heap limit that fits the host. ABAPiti's public osd-up.sh runs the pinned JS binary with a private STG_DB_PATH, and osd-m1.sh deploys generated classes through ADT. Its workflow uses the binary, not a Node heap flag; this checkout runner mirrors that file isolation and documents the extra heap needed to build a large folder at once. The recorded measurements use Node v26.9.0, the checkout's existing local runtime/transpiler 2.13.93 build and its resolved core 2.120.59. Each invocation owns its output and database; parallel runs leave the input folder, output/ and build/live untouched. The Go command additionally accepts --jobs N (default 4) and needs Go 1.26.

The generated support page inventories statements, built-ins, elementary declarations and conversions, joins per-class results for both runtimes, and lists kernel compatibility warnings. It is evidence from a corpus, not a specification. Regenerate from a read-only ABAPiti checkout with the commands below; flatten the split fixtures as the ABAPiti CI does, and repeat the two runtime commands for any extra qjs, mono and int8 folders under .local/abapiti. Retain JSON from partial runs so passing and failing classes keep their results. Declare full-folder runs using --runs <manifest.json>; each array entry has folder (input basename), runtime (osgo or osgjs) and file (relative to that manifest), or reason for a crash without class results. Full-folder runs covering every test owner with all rows SUCCESS credit helper classes as exercised by their tests; partial runs with failures leave helpers not measured; missing test owners leave helpers and omitted owners not measured. Harness crashes, OOM and setup failures before any class are not measured with a reason; fails applies only to test results. Manifest entries may include wallSeconds and peakRssKiB (GNU time maximum resident set size across the command and its children, including the build). Both runners snapshot provenance into their JSON: backend, heap override, installed runtime/transpiler and database versions, Node, and Go for osgo. A manifest's provenance can preserve those settings for a crash without JSON or an older run; it takes precedence over the result's snapshot. Missing metadata is printed as "not recorded". Regeneration reads the snapshots, so changes to installed tools or NODE_OPTIONS cannot rewrite historical provenance. The file backend uses node:sqlite, not better-sqlite; its SQLite version comes from the installed Node binary. Harness rows carry source: "harness"; assertion messages never determine provenance. Plain --osgo/--osgjs files give per-class evidence only, which is safe for runs restricted with --class.

Editors can import kernelWarnings and KERNEL_FORMS from tools/osd-kernel-compat.mjs, then call kernelWarnings([{file, source}]) on unsaved buffers. Each finding includes file, line, form, message and supportAnchor, a stable link into this page; KERNEL_FORMS lists the fixed anchors and titles. Show findings as Error diagnostics by default while allowing the code to run. osg.kernelStrict: "refuse" opts into refusal, matching the unit runners' --kernel-strict mode.

mkdir -p .local/support-work/go-cache .local/support-work/go-tmp .local/support-work/go-path
export GOPATH="$PWD/.local/support-work/go-path" GOMODCACHE="$PWD/.local/support-work/go-mod"
export GOTOOLCHAIN=go1.26.0 GOFLAGS=-buildvcs=false
export GOCACHE="$PWD/.local/support-work/go-cache" GOTMPDIR="$PWD/.local/support-work/go-tmp"
export ABAPITI_TEST_OUT="$PWD/.local/support-work/corpus"
OSD_HEAVY_RANGE=50-59 tools/osd-heavy.sh bash -c 'cd .local/abapiti-src && go test ./wasm -run "^TestOSD_EmitUnitClasses$" -count=1'
cp .local/support-work/corpus/TestOSD_EmitUnitClasses/split/*.abap .local/support-work/corpus/TestOSD_EmitUnitClasses/
rm -r .local/support-work/corpus/TestOSD_EmitUnitClasses/split
OSD_HEAVY_RANGE=50-59 tools/osd-heavy.sh bash -c 'timeout 1200 npm run -s osgo:unit -- .local/support-work/corpus/TestOSD_EmitUnitClasses --json > .local/support-work/osgo-corpus.json'
OSD_HEAVY_RANGE=50-59 tools/osd-heavy.sh bash -c '/usr/bin/time -f "wallSeconds=%e peakRssKiB=%M exit=%x" -o .local/support-work/osgjs-corpus.time timeout 1800 env NODE_OPTIONS=--max-old-space-size=12288 node tools/osgjs-unit.mjs .local/support-work/corpus/TestOSD_EmitUnitClasses --db file --json > .local/support-work/osgjs-corpus.json 2> .local/support-work/osgjs-corpus.err'
npm run osg:support -- .local/support-work/corpus/TestOSD_EmitUnitClasses --osgo .local/support-work/osgo-corpus.json --osgjs .local/support-work/osgjs-corpus.json --out docs/osg-support.md --json .local/support-work/support.json
# Append extra input folders and partial or successful --osgo/--osgjs files.
# To credit helpers, create a full-folder manifest (paths relative to this JSON):
# Run each extra folder on both runtimes with the same commands and timeout,
# writing osgo-{int8,mono,qjs}.json and osgjs-{int8,mono,qjs}.json.
# When remeasuring, update wallSeconds/peakRssKiB from each .time file.
# If a run has no JSON or only setup ERROR rows, retain its crash/setup reason.
# The committed page uses the following full-folder result files:
cat > .local/support-work/runs.json <<'JSON'
[
  {
    "folder": "TestOSD_EmitUnitClasses",
    "runtime": "osgo",
    "file": "osgo-corpus.json",
    "provenance": {
      "database": "modernc.org/sqlite",
      "heap": "Node default (no --max-old-space-size override)",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "Go": "go1.26.0"
      }
    }
  },
  {
    "folder": "TestOSD_EmitUnitClasses",
    "runtime": "osgjs",
    "file": "osgjs-corpus.json",
    "wallSeconds": 96.27,
    "peakRssKiB": 2590272,
    "provenance": {
      "database": "--db file (node:sqlite)",
      "heap": "--max-old-space-size=12288 MiB",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "node:sqlite (SQLite)": "3.53.4"
      }
    }
  },
  {
    "folder": "int8",
    "runtime": "osgo",
    "file": "osgo-int8.json",
    "provenance": {
      "database": "modernc.org/sqlite",
      "heap": "Node default (no --max-old-space-size override)",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "Go": "go1.26.0"
      }
    }
  },
  {
    "folder": "int8",
    "runtime": "osgjs",
    "file": "osgjs-int8.json",
    "wallSeconds": 23.06,
    "peakRssKiB": 1371808,
    "provenance": {
      "database": "--db file (node:sqlite)",
      "heap": "--max-old-space-size=12288 MiB",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "node:sqlite (SQLite)": "3.53.4"
      }
    }
  },
  {
    "folder": "mono",
    "runtime": "osgo",
    "file": "osgo-mono.json",
    "provenance": {
      "database": "modernc.org/sqlite",
      "heap": "Node default (no --max-old-space-size override)",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "Go": "go1.26.0"
      }
    }
  },
  {
    "folder": "mono",
    "runtime": "osgjs",
    "file": "osgjs-mono.json",
    "wallSeconds": 511.18,
    "peakRssKiB": 1636204,
    "provenance": {
      "database": "--db file (node:sqlite)",
      "heap": "--max-old-space-size=12288 MiB",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "node:sqlite (SQLite)": "3.53.4"
      }
    }
  },
  {
    "folder": "qjs",
    "runtime": "osgo",
    "file": "osgo-qjs.json",
    "provenance": {
      "database": "modernc.org/sqlite",
      "heap": "Node default (no --max-old-space-size override)",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "Go": "go1.26.0"
      }
    }
  },
  {
    "folder": "qjs",
    "runtime": "osgjs",
    "file": "osgjs-qjs.json",
    "wallSeconds": 1800.45,
    "peakRssKiB": 8879396,
    "reason": "30-minute timeout after a successful build with the larger heap and private file-backed SQLite; no class results; exit 124",
    "provenance": {
      "database": "--db file (node:sqlite)",
      "heap": "--max-old-space-size=12288 MiB",
      "versions": {
        "@abaplint/runtime": "2.13.93",
        "@abaplint/transpiler": "2.13.93",
        "Node": "v26.9.0",
        "node:sqlite (SQLite)": "3.53.4"
      }
    }
  }
]
JSON
# Exact command for the committed page:
npm run osg:support -- .local/support-work/corpus/TestOSD_EmitUnitClasses .local/abapiti/int8 .local/abapiti/mono .local/abapiti/qjs --runs .local/support-work/runs.json --out docs/osg-support.md --json .local/support-work/support.json
# Replace --out with --check docs/osg-support.md to compare without writing.

The header identifies generator content by combining the git blob hashes of tools/osg-support.mjs and tools/osd-kernel-compat.mjs into a short SHA-256 id, and lists both files and their blob hashes. The default date comes from the external ABAPiti commit, which is immutable; rebasing or squash-merging OSG therefore leaves the page and its exact --check comparison unchanged. To override metadata explicitly, append --osg-rev <hex-id> --date <yyyy-mm-dd>.

Architecture

A generation is one transpiled system named by the hash of its inputs (the layers of abap_transpile.json, the packs, and the generated gen/). Moving the live pointer to another generation recycles the work processes, and moving it back is a rollback. The browser build bundles the same output into a service worker. More: docs/generations.md, docs/architecture-split.md.

Run it

Node 22.18+ (major 22) or Node 24. 22.18 is the first Node 22 that strips TypeScript types without a flag; the gogen typing work moves tools to .ts.

git clone https://github.com/oisee/open-steamgate && cd open-steamgate
npm ci
npm run bootstrap            # pinned library clones + packs, then gen/
npm start                    # http://localhost:3030/ is the launchpad
npm run dev                  # the same, rebuilding as you edit ABAP
npm test                     # abaplint + ABAP Unit + mocha over the wire
npm run e2e:install && npm run e2e         # Playwright
npm run web:preview && npm run web:serve   # the browser-only build on :3031
npm run start:duckdb         # on DuckDB (STG_DB_PATH=x.duckdb persists)
npm run unit:hana            # on a real HANA
npm run binary && build/osd up             # the workbench as one Bun binary
npm run vsix                 # the VS Code extension

HANA Express: running its image accepts SAP's developer licence, see docs/amdp-in-hana.md. npm run bootstrap reads libs.lock.json: it clones the pinned libraries into .local/lars/, fetches the packs and runs the first transpile.

Build on it

docs/using-osd.md is the working guide. In short:

• A service is one YAML file (npm run stg:compile): SEGW without the GUI. An entity reads from a table, a CDS view, a function module, a search help, another service, or a hand-written GET_ENTITYSET.
• OData from CDS needs one annotation: @OData.publish: true.
• Content comes as a pack: a directory with osd-pack.json, dropped into packs/, layered after the tree. A collision is reported with both files.
• A real system is reached with a zip. npm run segw:zip builds an abapGit offline repository, and a Fiori app goes as a BSP application with its ICF node (docs/a4h-deploy.md).
• A worked example, as a book: osg-demo — The Airship Fleet / Флот дирижаблей builds one ABAP application on open-steamgate chapter by chapter, from a first class to OData, Fiori, CDS, jobs, osabap and abaplint in ABAP. Every chapter runs against a pinned open-steamgate tag; EPUB and PDF, English and Russian, are on the releases page.

Thanks

This is grown on Lars Hvam's work and would not exist without it: abaplint and the transpiler turn the ABAP into something that runs, open-abap is the runtime library under it, and abapGit is how code gets in and out. Fixes go back upstream, one small PR each (docs/upstream.md).

Family

• vsp / vibing-steampunk: MCP server and CLI for ADT, SAP-LZH decode, abapGit deploy-back.
• open-rfc-go: pure-Go NI / RFC / CPIC transport, used as an external oracle.
• sap-lsd, sap-tui: the DIAG light-show and the terminal viewer behind the LSD tile.

Protocol facts from two private siblings are summarised in docs/layers-we-own.md.

Prior art

MIT unless noted; the evidence is in docs/prior-art.md. abaplint/transpiler · open-abap/open-abap-odata (the /IWBEP/ interfaces; its licence is still unclear, so we use it as interfaces only) · abapGit · SAP/open-ux-odata (Apache-2.0, studied as the conformance reference, not a dependency) · larshp/hithub (the browser preview's recipe).

License

MIT — see LICENSE. This is a clean-room reimplementation of the /IWBEP/ interfaces. It bundles no SAP source and no standard DDIC.