gwbasickernel 0.1.0__tar.gz

gwbasickernel-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eremey Valetov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gwbasickernel-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+prune tests
+include tests/test_kernel_package.py

gwbasickernel-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: gwbasickernel
+Version: 0.1.0
+Summary: Jupyter kernel for GW-BASIC 2026 with inline graphics
+Author: Eremey Valetov
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/evvaletov/gw-basic-2026
+Project-URL: Documentation, https://evvaletov.github.io/gw-basic-2026/
+Project-URL: Issues, https://github.com/evvaletov/gw-basic-2026/issues
+Classifier: Framework :: Jupyter
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipykernel>=6
+Requires-Dist: jupyter_client>=8
+Requires-Dist: pygments>=2
+Dynamic: license-file
+
+# GW-BASIC Jupyter kernel
+
+Run GW-BASIC programs in JupyterLab or Notebook. Variables and program lines
+persist between cells. The kernel converts the interpreter's Sixel output to
+inline PNG images, so the notebook browser does not need Sixel support.
+
+Requires Python 3.10 or later and the native
+[GW-BASIC 2026 interpreter](https://github.com/evvaletov/gw-basic-2026)
+on Linux or macOS. The Python package does not include that interpreter.
+The DOS executables cannot be used as the notebook backend.
+
+## Install the interpreter
+
+With Homebrew on Linux or macOS:
+
+```sh
+brew tap evvaletov/gwbasic https://github.com/evvaletov/gw-basic-2026.git
+brew install evvaletov/gwbasic/gwbasic
+```
+
+The Homebrew formula builds from a pinned source revision. It includes the
+interpreter and native compiler, with PulseAudio disabled.
+
+Alternatively, build from source with a C11 compiler and CMake:
+
+```sh
+git clone https://github.com/evvaletov/gw-basic-2026.git
+cd gw-basic-2026
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build --parallel 2
+export GWBASIC="$PWD/build/gwbasic"
+```
+
+## Install the kernel
+
+Create a Python environment for the kernel and JupyterLab:
+
+```sh
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install gwbasickernel jupyterlab
+gwbasickernel-install --sys-prefix
+jupyter lab
+```
+
+Choose **GW-BASIC 2026** when creating a notebook. The kernel looks for the
+interpreter in `GWBASIC`, then on `PATH`. To save its location in the kernelspec,
+use this command instead of the installer command above:
+
+```sh
+gwbasickernel-install --sys-prefix --gwbasic /absolute/path/to/gwbasic
+```
+
+If Jupyter runs in another Python environment, use `--user` to register the
+kernel for your account. Keep the kernel's Python environment in place:
+the kernelspec records its Python executable.
+
+## Try it
+
+```basic
+10 FOR N=1 TO 8
+20 PRINT N;N*N
+30 NEXT N
+RUN
+```
+
+For graphics, clear the previous program first:
+
+```basic
+NEW
+10 SCREEN 1
+20 CIRCLE (160,100),80,2
+RUN
+```
+
+See the [executed graphics notebook](https://github.com/evvaletov/gw-basic-2026/blob/main/examples/graphics.ipynb)
+and [demo guide](https://github.com/evvaletov/gw-basic-2026/blob/main/docs/demos.md).
+
+`%new` clears the BASIC program; `%reset` starts a fresh interpreter process.
+`%timeout 60` changes the output wait timeout from its default of 30 seconds.

gwbasickernel-0.1.0/README.md

@@ -0,0 +1,247 @@
+# GW-BASIC 2026
+
+A portable C reimplementation of Microsoft GW-BASIC, using the
+[original 8088 assembly source](https://github.com/microsoft/GW-BASIC)
+(released by Microsoft in 2020) as the authoritative reference.
+
+The interpreter implements the language in C11 and aims to reproduce the
+original behavior. Hardware access uses emulation or device stubs; see the
+[language reference](docs/language-reference.md) for their limits.
+
+## Demos
+
+### FreeDOS editor
+
+The 16-bit interpreter, installed with FreeDOS's FDINST package installer, listing and running [squares.bas](examples/squares.bas) in QEMU:
+
+![GW-BASIC full-screen editor in FreeDOS, showing the squares program and its output](docs/images/freedos-editor.png)
+
+### Native compilation
+
+The same listing compiles through C to a native executable. These commands run from the repository root after building:
+
+```text
+cp examples/squares.bas build/squares.bas
+build/gwbasic-compile build/squares.bas -c --keep-c --runtime .
+build/squares
+```
+
+The executable prints the same table of squares as the interpreter. `build/squares.c` contains the generated C.
+
+### Notebook graphics
+
+[graphics.ipynb](examples/graphics.ipynb) runs [circles.bas](examples/circles.bas) through the Jupyter kernel. The kernel converts the interpreter's Sixel output to inline PNG images. This preview shows the final frame from the executed notebook's HTML export:
+
+![Executed BASIC notebook with a SCREEN 1 program and its concentric circles](docs/images/notebook-graphics.png)
+
+See [Reproducing the demos](docs/demos.md) for installation, commands, capture details and limitations.
+
+## Building
+
+```bash
+mkdir -p build
+(cd build && cmake ..)
+cmake --build build
+```
+
+The POSIX build requires a C11 compiler, CMake 3.12+, and `pkg-config`.
+PulseAudio (`libpulse-simple`) is optional and detected at build time for
+`SOUND`/`BEEP`/`PLAY` audio output.
+
+Builds three targets:
+
+- `gwbasic` -- the interpreter
+- `gwbasic-compile` -- the ahead-of-time compiler
+- `libgwrt.a` -- runtime library for compiled programs
+
+## Usage
+
+Run these commands from the repository root. Interactive mode launches a
+GW-BASIC-style full-screen editor:
+
+```
+$ build/gwbasic
+GW-BASIC 2026 0.18.2
+(C) Eremey Valetov 2026. MIT License.
+Based on Microsoft GW-BASIC assembly source.
+Ok
+PRINT 2+2
+ 4
+Ok
+```
+
+Run a program file (ASCII or binary tokenized):
+
+<!-- docs-test: readme-run -->
+```bash
+build/gwbasic tests/programs/prime_sieve.bas
+```
+
+Compile to a native executable:
+
+<!-- docs-test: readme-compile -->
+```bash
+build/gwbasic-compile tests/programs/fibonacci.bas -c --runtime .
+```
+
+## Ahead-of-Time Compiler
+
+`gwbasic-compile` translates ASCII BASIC programs to C source. With `-c`,
+it invokes GCC to produce native executables linked against `libgwrt.a`.
+GCC is required for this path even if the interpreter was built with Clang.
+
+Pipeline: `.bas` → tokenizer → analysis → C codegen → `gcc` → native binary.
+
+The compiler test harness compares eligible programs with the expected-output
+files. It skips interactive, timing-dependent, and audio tests, plus helper
+programs loaded by other tests. Passing that suite does not establish full
+GW-BASIC compatibility; compiled timer and key event handlers are unsupported.
+
+Save this example as `myprog.bas`:
+
+<!-- docs-test: readme-program -->
+```basic
+10 PRINT "HELLO FROM BASIC"
+20 END
+```
+
+<!-- docs-test: readme-compiler -->
+```bash
+# Generate C source
+build/gwbasic-compile myprog.bas -o myprog.c
+
+# Compile to executable (automatic)
+build/gwbasic-compile myprog.bas -c --runtime .
+```
+
+## VS Code extension
+
+The [VS Code extension](editors/vscode/README.md) adds highlighting, snippets,
+F5 Run, and native compilation in the integrated terminal. Install its VSIX
+from the `vscode-extension-stable` CI artifact, then configure the interpreter and
+compiler paths. The extension and runtime are packaged separately.
+
+## Homebrew
+
+Install the interpreter and native compiler on Linux or macOS:
+
+```sh
+brew tap evvaletov/gwbasic https://github.com/evvaletov/gw-basic-2026.git
+brew install evvaletov/gwbasic/gwbasic
+```
+
+The formula builds from a pinned source revision with PulseAudio disabled.
+`gwbasic-compile program.bas -c` uses the installed runtime automatically.
+Native compilation requires `gcc` on `PATH` (Apple's `gcc` command invokes
+Clang on macOS).
+
+## Jupyter Kernel
+
+A Jupyter notebook kernel for GW-BASIC with inline Sixel graphics
+rendering, INPUT support, and Pygments syntax highlighting. Requires Python
+3.10 or later and the native interpreter on Linux or macOS.
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install gwbasickernel jupyterlab
+gwbasickernel-install --sys-prefix
+jupyter lab  # select "GW-BASIC 2026" kernel
+```
+
+See the [kernel installation guide](gwbasickernel/README.md) for interpreter
+setup and kernels installed in a different Python environment. To develop the
+kernel from this checkout, use `python -m pip install -e .`.
+
+## What Works
+
+The interpreter covers the language features below. Device-specific operations
+include emulated ports, fixed return values, and unsupported machine-code calls.
+
+Data types: INTEGER (%), SINGLE (!), DOUBLE (#), STRING ($)
+
+Operators: `+ - * / ^ \ MOD AND OR XOR EQV IMP NOT < = > <= >= <>`
+
+Statements:
+
+| Category | Statements |
+|----------|------------|
+| Output | PRINT, LPRINT, LLIST, PRINT USING, WRITE, CLS |
+| Variables | LET, DIM, ERASE, SWAP, DEFINT/SNG/DBL/STR |
+| Control flow | GOTO, GOSUB/RETURN, FOR/NEXT, IF/THEN/ELSE, WHILE/WEND, ON...GOTO/GOSUB |
+| Input | INPUT, LINE INPUT, DATA/READ/RESTORE, INKEY$ |
+| Program | RUN, CONT, STOP, END, NEW, LIST, CLEAR, AUTO, RENUM, DELETE, EDIT |
+| Sequential I/O | OPEN, CLOSE, PRINT#, WRITE#, INPUT#, LINE INPUT# |
+| Random-access I/O | FIELD, LSET, RSET, PUT, GET, CVI/CVS/CVD, MKI$/MKS$/MKD$ |
+| Program I/O | SAVE (binary/ASCII), LOAD (auto-detects), MERGE, CHAIN, COMMON |
+| Event trapping | ON TIMER(n) GOSUB, TIMER ON/OFF/STOP, ON KEY(n) GOSUB |
+| Error handling | ON ERROR GOTO, RESUME, ERROR, ERR, ERL |
+| User functions | DEF FN, RANDOMIZE |
+| File management | KILL, NAME, FILES, MKDIR, RMDIR, CHDIR, SHELL, ENVIRON |
+| Date/time | DATE$, TIME$, TIMER |
+| Screen | LOCATE, COLOR, WIDTH, SCREEN, KEY ON/OFF/LIST |
+| Graphics | PSET, PRESET, LINE, CIRCLE, DRAW, PAINT, GET/PUT (sprites), VIEW, WINDOW, PALETTE, PMAP |
+| Sound | SOUND, BEEP, PLAY (MML) |
+| Memory | DEF SEG, PEEK, POKE, BSAVE, BLOAD |
+| Hardware I/O | OUT, INP, WAIT, MOTOR, STICK, STRIG |
+
+## Tests
+
+Run the regression suites from the repository root:
+
+```bash
+python3 tests/test_harnesses.py          # harness failure and timeout checks
+bash tests/run_tests.sh                 # interpreter
+bash tests/run_compiler_tests.sh        # compiled programs
+bash tests/run_corpus.sh --report corpus-matrix.json  # curated compatibility cases
+python3 -m gwbasickernel.test_kernel     # Jupyter kernel
+```
+
+For an interpreter run without audio playback:
+
+```bash
+PULSE_SERVER=unix:/tmp/gwbasic-no-audio-server bash tests/run_tests.sh
+```
+
+This points PulseAudio at an unavailable socket, as the interpreter CI step does.
+Audio fixtures have a 30-second limit so they can also finish with a live server.
+Output mismatches, execution failures, and timeouts fail the suites. See
+[Development](docs/development.md) for timeout settings and test coverage.
+
+The [compatibility corpus](tests/corpus/README.md) contains 98 original BASIC
+Computer Games listings. Its automated runtime suite checks 53 fixed-input cases
+from twenty-six listings against Microsoft GW-BASIC transcripts and compares six
+compiler modes with the interpreter. The other listings have build-audit
+coverage only. Awari and Checkers compile; Super Star Trek is rejected for an
+unspaced `TO` expression that Microsoft GW-BASIC also rejects.
+
+## DOS / FreeDOS
+
+Cross-compiles to DOS with OpenWatcom V2:
+
+```bash
+wmake -f Makefile.dos16   # 16-bit real mode, no extender
+wmake -f Makefile.dos     # 32-bit DOS/4GW, requires DOS4GW.EXE
+```
+
+The 16-bit build runs on FreeDOS, MS-DOS, and compatible systems without
+a DOS extender.  See [Getting Started](docs/getting-started.md) for details.
+
+## Release archives
+
+The v0.18.2 [release notes](RELEASE_NOTES.md) describe the Linux and DOS archives,
+checksums, and validation limits. CI builds archives after its checks pass;
+publication is a separate step.
+
+## Documentation
+
+Full Sphinx documentation in `docs/`:
+
+```bash
+cd docs && pip install -r requirements.txt && make html
+```
+
+## License
+
+The implementation uses the [MIT License](LICENSE). The vendored BASIC Computer
+Games listings in `tests/corpus/` use the upstream [Unlicense](tests/corpus/LICENSE).

gwbasickernel-0.1.0/gwbasickernel/README.md

@@ -0,0 +1,80 @@
+# GW-BASIC Jupyter kernel
+
+Run GW-BASIC programs in JupyterLab or Notebook. Variables and program lines
+persist between cells. The kernel converts the interpreter's Sixel output to
+inline PNG images, so the notebook browser does not need Sixel support.
+
+Requires Python 3.10 or later and the native
+[GW-BASIC 2026 interpreter](https://github.com/evvaletov/gw-basic-2026)
+on Linux or macOS. The Python package does not include that interpreter.
+The DOS executables cannot be used as the notebook backend.
+
+## Install the interpreter
+
+With Homebrew on Linux or macOS:
+
+```sh
+brew tap evvaletov/gwbasic https://github.com/evvaletov/gw-basic-2026.git
+brew install evvaletov/gwbasic/gwbasic
+```
+
+The Homebrew formula builds from a pinned source revision. It includes the
+interpreter and native compiler, with PulseAudio disabled.
+
+Alternatively, build from source with a C11 compiler and CMake:
+
+```sh
+git clone https://github.com/evvaletov/gw-basic-2026.git
+cd gw-basic-2026
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build --parallel 2
+export GWBASIC="$PWD/build/gwbasic"
+```
+
+## Install the kernel
+
+Create a Python environment for the kernel and JupyterLab:
+
+```sh
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install gwbasickernel jupyterlab
+gwbasickernel-install --sys-prefix
+jupyter lab
+```
+
+Choose **GW-BASIC 2026** when creating a notebook. The kernel looks for the
+interpreter in `GWBASIC`, then on `PATH`. To save its location in the kernelspec,
+use this command instead of the installer command above:
+
+```sh
+gwbasickernel-install --sys-prefix --gwbasic /absolute/path/to/gwbasic
+```
+
+If Jupyter runs in another Python environment, use `--user` to register the
+kernel for your account. Keep the kernel's Python environment in place:
+the kernelspec records its Python executable.
+
+## Try it
+
+```basic
+10 FOR N=1 TO 8
+20 PRINT N;N*N
+30 NEXT N
+RUN
+```
+
+For graphics, clear the previous program first:
+
+```basic
+NEW
+10 SCREEN 1
+20 CIRCLE (160,100),80,2
+RUN
+```
+
+See the [executed graphics notebook](https://github.com/evvaletov/gw-basic-2026/blob/main/examples/graphics.ipynb)
+and [demo guide](https://github.com/evvaletov/gw-basic-2026/blob/main/docs/demos.md).
+
+`%new` clears the BASIC program; `%reset` starts a fresh interpreter process.
+`%timeout 60` changes the output wait timeout from its default of 30 seconds.

gwbasickernel-0.1.0/gwbasickernel/__init__.py

@@ -0,0 +1,3 @@
+"""Jupyter kernel for GW-BASIC 2026."""
+
+__version__ = '0.1.0'

gwbasickernel-0.1.0/gwbasickernel/__main__.py

@@ -0,0 +1,4 @@
+from ipykernel.kernelapp import IPKernelApp
+from .kernel import GWBasicKernel
+
+IPKernelApp.launch_instance(kernel_class=GWBasicKernel)

gwbasickernel-0.1.0/gwbasickernel/basic_lexer.py

@@ -0,0 +1,79 @@
+"""Pygments lexer for GW-BASIC."""
+
+from pygments.lexer import RegexLexer
+from pygments.token import (
+    Comment, Keyword, Name, Number, Operator, Punctuation, String, Text,
+)
+
+
+class GWBasicLexer(RegexLexer):
+    name = 'GW-BASIC'
+    aliases = ['gwbasic', 'basic']
+    filenames = ['*.bas', '*.BAS']
+    mimetypes = ['text/x-basic']
+
+    tokens = {
+        'root': [
+            # REM comments (to end of line)
+            (r"(?i)\bREM\b.*$", Comment.Single),
+            # Single-quote comments
+            (r"'.*$", Comment.Single),
+
+            # String literals
+            (r'"[^"]*"', String.Double),
+
+            # Line numbers at start of line
+            (r'^\s*\d+', Name.Label),
+
+            # Hex and octal literals
+            (r'&[Hh][0-9A-Fa-f]+', Number.Hex),
+            (r'&[Oo]?[0-7]+', Number.Oct),
+
+            # Floating point
+            (r'\d+\.\d*([eEdD][+-]?\d+)?[!#]?', Number.Float),
+            (r'\d+[eEdD][+-]?\d+[!#]?', Number.Float),
+
+            # Integer
+            (r'\d+[%!#]?', Number.Integer),
+
+            # Statements / keywords
+            (r'(?i)\b(AUTO|BEEP|BLOAD|BSAVE|CALL|CALLS|CHAIN|CHDIR|CIRCLE'
+             r'|CLEAR|CLOSE|CLS|COLOR|COM|COMMON|CONT|DATA|DEF\s+SEG'
+             r'|DEF\s+FN|DEFDBL|DEFINT|DEFSNG|DEFSTR|DELETE|DIM|DRAW'
+             r'|EDIT|ELSE|END|ENVIRON|ERASE|ERROR|FIELD|FILES|FOR|GET'
+             r'|GOSUB|GOTO|IF|INPUT|KEY|KILL|LCOPY|LET|LINE\s+INPUT'
+             r'|LINE|LIST|LLIST|LOAD|LOCATE|LPRINT|LSET|MERGE|MKDIR'
+             r'|MOTOR|NAME|NEW|NEXT|ON|OPEN|OPTION\s+BASE|OUT|PAINT'
+             r'|PALETTE|PLAY|POKE|PRESET|PRINT|PSET|PUT|RANDOMIZE'
+             r'|READ|REM|RENUM|RESET|RESTORE|RESUME|RETURN|RMDIR|RSET'
+             r'|RUN|SAVE|SCREEN|SHELL|SOUND|STOP|SWAP|SYSTEM|THEN|TIMER'
+             r'|TO|TRON|TROFF|USING|VIEW|WAIT|WEND|WHILE|WIDTH|WINDOW'
+             r'|WRITE)\b', Keyword),
+
+            # Built-in functions
+            (r'(?i)\b(ABS|ASC|ATN|CDBL|CHR\$|CINT|COS|CSNG|CSRLIN'
+             r'|CVD|CVI|CVS|DATE\$|EOF|ENVIRON\$|ERDEV\$?|ERL|ERR'
+             r'|EXP|FIX|FN|FRE|HEX\$|INKEY\$|INP|INPUT\$|INSTR|INT'
+             r'|IOCTL\$|LEFT\$|LEN|LOC|LOF|LOG|LPOS|MID\$|MKD\$'
+             r'|MKI\$|MKS\$|OCT\$|PEEK|PEN|PMAP|POINT|POS|RIGHT\$'
+             r'|RND|SGN|SIN|SPACE\$|SPC|SQR|STICK|STR\$|STRIG'
+             r'|STRING\$|TAB|TAN|TIME\$|TIMER|USR|VAL|VARPTR\$?)\b',
+             Name.Builtin),
+
+            # Logical / arithmetic operators as keywords
+            (r'(?i)\b(AND|EQV|IMP|MOD|NOT|OR|XOR|STEP)\b', Operator.Word),
+
+            # Operators
+            (r'[+\-*/\\^<>=]', Operator),
+            (r'<>|<=|>=', Operator),
+
+            # Punctuation
+            (r'[(),;:#]', Punctuation),
+
+            # Identifiers (variable names)
+            (r'[A-Za-z][A-Za-z0-9]*[%!#$]?', Name),
+
+            # Whitespace
+            (r'\s+', Text),
+        ],
+    }

gwbasickernel-0.1.0/gwbasickernel/install.py

@@ -0,0 +1,60 @@
+"""Install the GW-BASIC kernel into Jupyter."""
+
+import argparse
+import json
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+
+def install_kernel(user=True, prefix=None, gwbasic=None):
+    from jupyter_client.kernelspec import KernelSpecManager
+
+    spec = json.loads((Path(__file__).parent / 'kernel.json').read_text())
+    spec['argv'][0] = sys.executable
+    if gwbasic is not None:
+        binary = shutil.which(str(gwbasic))
+        if binary is None:
+            raise ValueError(f'GW-BASIC executable not found: {gwbasic}')
+        spec['env'] = {'GWBASIC': str(Path(binary).absolute())}
+
+    with tempfile.TemporaryDirectory() as td:
+        dest = Path(td) / 'gwbasic'
+        dest.mkdir()
+        (dest / 'kernel.json').write_text(json.dumps(spec, indent=2) + '\n')
+
+        ksm = KernelSpecManager()
+        ksm.install_kernel_spec(
+            str(dest), kernel_name='gwbasic', user=user, prefix=prefix,
+        )
+
+    print('GW-BASIC kernel installed successfully.')
+    print('Run "jupyter kernelspec list" to verify.')
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Install the GW-BASIC Jupyter kernel')
+    location = parser.add_mutually_exclusive_group()
+    location.add_argument('--user', action='store_true',
+                        help='Install for the current user (default)')
+    location.add_argument('--sys-prefix', action='store_true',
+                        help='Install into sys.prefix (for virtualenvs)')
+    location.add_argument('--prefix', type=str, default=None,
+                        help='Install into a specific prefix')
+    parser.add_argument('--gwbasic', help='Interpreter executable to save in the kernelspec')
+    args = parser.parse_args()
+
+    try:
+        if args.sys_prefix:
+            install_kernel(user=False, prefix=sys.prefix, gwbasic=args.gwbasic)
+        elif args.prefix:
+            install_kernel(user=False, prefix=args.prefix, gwbasic=args.gwbasic)
+        else:
+            install_kernel(gwbasic=args.gwbasic)
+    except ValueError as exc:
+        parser.error(str(exc))
+
+
+if __name__ == '__main__':
+    main()

gwbasickernel-0.1.0/gwbasickernel/kernel.json

@@ -0,0 +1,8 @@
+{
+  "argv": ["python", "-m", "gwbasickernel", "-f", "{connection_file}"],
+  "display_name": "GW-BASIC 2026",
+  "language": "basic",
+  "metadata": {
+    "debugger": false
+  }
+}