Vibeleaderboard
Index / tool
Visit github.com
Category
Developer Tools
Rank
No. 1477Tools index

Previous survey · No. 1443 ·

Pricing
Open Source
Type
TOOL
Use case
Coding
Interfaces
MCP
GitHub
19 stars
Latest release
v1.1.0
Date

About

jdBasic is a modern BASIC interpreter built on a custom bytecode VM, combining APL-style array operations, SDL3 graphics, Win32 forms, and Godot engine embedding with local LLM/ONNX inference. Its built-in MCP server exposes the persistent, running VM so AI agents like Claude Code can pause a live program, edit variables or recompile source, and resume execution without losing state.

What it does

A BASIC dialect whose compiler turns programs into bytecode for its own virtual machine, bundled with extras: whole-array math in the style of APL, 2D graphics and immediate-mode GUIs, real Windows forms, a music tracker, and local model inference. The headline trick is that the interpreter keeps running state around. You can pause a program, change a variable or swap in a rewritten subroutine, and resume from the same instruction. Run as a Model Context Protocol (MCP) server, it hands that pause, patch and resume loop to a coding agent such as Claude Code or Cursor, so the agent edits a game while it is still on screen.

Why it's ranked here

Few MCP servers give an agent a live, stateful runtime instead of a fresh process per call, and this one documents exactly how it does it: one shared VM across every tool call, a 30-second default watchdog that parks runaway code without wedging the session, and a documentation lookup tool meant to stop models inventing builtins that do not exist. MIT licensed, with a CI workflow, a browser playground and prebuilt release binaries. The catch is scope. This is one author's language, so an agent gains a live runtime only for programs written in jdBasic.

What's good

The agent integration is specific rather than decorative. Fourteen documented tools cover running code, linting without running, listing variables and functions, saving and restoring workspaces, and pausing and resuming a running script, and the pause and status calls answer even while another call is busy. The build is modular: the minimal binary is just the VM and standard library, and the MCP-ready Core release is about 8 MB with no LLVM needed. The language reference is candid about its own traps, explaining why comparing a value to NONE misleads and adding a null-coalescing operator so the correct check is the shorter one.

Tradeoffs

Security is the user's job. The MCP tools run arbitrary code with filesystem, shell, network and native function access, and the HTTP transport has no built-in authentication, so the docs say to bind it to localhost. Building from source means hand-downloading SDL3, ImGui, ONNX Runtime and LLVM 18 into an ignored libraries folder, and the runtime library for compiled executables must be rebuilt with identical feature flags or those programs lose builtins. The one CMake file lists five sources and none of the feature flags, so the real build lives in the platform scripts. Forms and COM automation are Windows only.

How to use it well

Best fit: a tinkerer who misses the VB6 habit of editing a program mid-run and now wants an agent doing the edits, especially on small games, GUI tools and data experiments. Grab the Core release, point your MCP client at the binary with the MCP flag, and have the agent look names up with the documentation tool before it evaluates code. Keep the server on stdio or localhost and run it under your own account. It does nothing for code in Python, JavaScript or any other language: live patching only works inside jdBasic programs.

Technical notes+

Per doc/MCP.md the built-in server speaks stdio via jdbasic --mcp or HTTP via --mcp-http 7321, and every tool shares one persistent VM; jdb_eval takes an optional timeout_ms (default 30000, 0 disables) and jdb_stop/jdb_status are fast-pathed on the reader thread. jdb_doc does substring lookup against doc/languages.md, resolved relative to the binary first, which is why doc/README.md calls that file's one-bullet-per-function format load-bearing. doc/BUILD.md gates the server behind the MCPSERVER flag, and the Security section of doc/MCP.md lists OS.EXEC, SHELL, sockets and DECLARE FUNC FFI as reachable from eval. CMakeLists.txt declares project basic_interpreter version 1.0 with only main, lexer, parser, compiler and vm sources and no feature options, so it does not reproduce the documented builds. A separate MCP server written in jdBasic, jdb/demos/mcp_server/server.jdb, implements Streamable HTTP with Mcp-Session-Id sessions and a different tool set (jdb_save_state, jdb_restore_state), and its own jdb_run_native description says it has no timeout. src/main.cpp pulls in each subsystem header behind its build macro (MCPSERVER, GFX, FORMS, SQLITE, LLVM_CODEGEN). lib/llmapi.jdb wraps OpenAI, Anthropic and local GGUF models behind one message shape, reading keys from OPENAI_API_KEY or ANTHROPIC_API_KEY, and states streaming is not supported.

Observed

License
MIT (LICENSE.txt)
Implementation language
C++17 interpreter core; programs and the bundled module library are written in jdBasic
Interfaces
CLI interpreter with REPL, MCP server over stdio and HTTP, DAP debug adapter for VS Code, native compiler to standalone executables
MCP authentication
None built in; the HTTP transport is documented as localhost-only unless fronted by an auth proxy
MCP tool reach
Evaluated code can read and write files, spawn processes, open network connections and call native functions
Build system
Feature-flag build scripts for Windows (MSVC) and Linux; third-party libraries are unpacked manually into a gitignored libs directory
Packaging
Prebuilt GitHub release binaries in Core and Full variants; Full adds LLVM 18 for native compilation
Platform-specific features
Win32 forms and COM automation are Windows only
Authorship
README written in the first person by a single author; copyright held by Computerwelt AI Solutions LLC

Read from README.md, LICENSE.txt, CMakeLists.txt, doc/README.md, doc/BUILD.md, doc/MCP.md, doc/languages.md, src/main.cpp, lib/README.md, lib/llmapi.jdb, jdb/demos/mcp_server/server.jdb.

What it can do

  • Execute BASIC programs using a bytecode virtual machine

    BASIC source code → Program execution

  • Perform APL-style array operations

    Array data → Transformed arrays

  • Render graphics using SDL3/ImGui

    Graphics/UI commands → Rendered visuals

  • Embed and control the Godot engine

    Godot engine integration code → Embedded engine session

  • Run local LLM/ONNX inference

    Model input data → Inference results

  • Expose a running program's VM via an MCP server for AI agents

    Live running BASIC program → Pausable, inspectable VM state

  • Pause, edit variables, and recompile a live running program

    Running program state and new source → Modified running program

  • Resume program execution after live editing without losing state

    Paused/edited program → Continued execution with preserved state

Tags

basicprogramming-languageaplmcpai-pair-programminggodotvirtual-machineinterpreter

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.