Skip to content

Roadmap

Current phase

Library-test closure

Completed milestones

14 / 17

Last updated

August 3, 2026

The first native Gobb executable is now working. It evaluates expressions, files, and stdin through Glojure and is compiled to a native binary by Gloat. The same architecture now powers native and live browser-Wasm REPLs using Babashka's reusable REPL loop. A strict differential harness records current BB compatibility for interpreted and compiled programs. Gobb remains an architecture proof, not yet a general BB replacement. The generated BB surface ledger now tracks 1,022 CLI, project, namespace, library, Java-class, platform, upstream-test, and representative-program items with explicit compatibility states and milestone assignments.

Current work

14
In progress

Library-test closure

Make every applicable test in Babashka's test-resources/lib_tests corpus pass, with documented waivers for genuinely non-portable behavior.

  • Establish the 261-namespace baseline: 2 pass, 2 fail, and 257 blocked
  • First closure checkpoint: 12 pass, 32 fail, and 217 blocked
  • Second closure checkpoint: 25 pass, 23 fail, and 213 blocked
  • Third closure checkpoint: 35 pass, 18 fail, and 208 blocked
  • Fourth closure checkpoint: 50 pass, 23 fail, and 188 blocked
  • Fifth closure checkpoint: 60 passing namespaces
  • Sixth closure checkpoint: 70 passing namespaces
  • Seventh closure checkpoint: 80 passing namespaces
  • Eighth closure checkpoint: 91 pass, 13 fail, and 157 blocked
  • Current verified result: 94 pass, 10 fail, and 157 blocked
  • Install 96 of 104 Maven dependency roots independently with Grenadine
  • Add signed-byte arrays, numeric-tower rounding, and multi-type JVM marker compatibility
  • Load Clojure pprint through hosted Writer proxies and eliminate its runtime errors
  • Pass Numeric Tower, Aviso Binary, SFV Parser, and Omniconf in the full 261-namespace run
  • Finish the two JSON suites, currently at 99/100 and 55/56 assertions
  • Restore clj-commons.digest-test, which regressed from 9/9 to 3/9 passing assertions
  • Implement deftype support for the seven-namespace Schema cluster and other portable libraries
  • Resolve the eight remaining dependency roots, including core.async and core.rrb-vector
  • Continue closing Glojure host-interop and evaluator gaps exposed by runnable tests
  • Turn runnable failures into passing differential results
  • Document waivers only for genuinely non-portable behavior
  • Pass every applicable library-test namespace

Completed foundation

0
Complete

Repository foundation and Makes automation

Establish reproducible Makes-managed tooling, cleanup, website commands, and the initial project structure.

  • Architecture and complete roadmap written
  • Initial MkDocs website created
  • make serve and make publish wired
  • gobb.site custom domain configured
  • Branded social cards generated from the hero artwork
  • Social-card image URLs cache-busted on each website build
  • Clean Make-managed tool provisioning validated
  • Runtime build and test targets added
  • Install, cross-platform release, and final website publication automated
  • OpenBSD and NetBSD amd64/arm64 release artifacts verified
  • Live browser-Wasm REPL added to the website
  • Shareable browser REPL history URLs

Completed execution architecture

1
Complete

Prove the execution architecture

Expand the working native executable into the complete execution proof, including runtime namespace loading and the first Wasm artifact.

  • make build produces bin/gobb
  • gobb -e EXPR [ARGS...]
  • gobb FILE [ARGS...]
  • Source evaluation from stdin
  • Definitions persist across multiple forms
  • Useful CLI errors and nonzero exit status
  • Focused differential tests against BB
  • Runtime require from the working directory and -cp/--classpath
  • WASI and browser-Wasm smoke artifacts
  • Babashka REPL loop compiled with Gloat for the browser
  • gobb starts a native user=> REPL
  • Native multiline input, help, exit, and error recovery
  • Persistent REPL values and *1 history verified
  • BB-compatible babashka.version, babashka.file, and initial java.class.path properties
  • REPL errors expose the underlying evaluator message
  • Runtime (ns ...) support verified with Gloat 0.1.67 and Glojure 0.7.3
  • Dependency-free gobb build compilation spike
  • One portable smoke program produces equivalent evaluated and compiled output
  • Native, WASI, and browser-Wasm smoke artifacts are executed by tests

Completed compatibility harness

2
Complete

Differential BB compatibility harness

Run the same fixtures under the pinned BB executable and the current Gobb, preserving complete diagnostics for every unexpected difference.

  • Build a reusable fixture runner for pinned BB and current Gobb
  • Compare standard output
  • Compare standard error
  • Compare exit status
  • Compare structured exception data
  • Compare expected filesystem effects
  • Normalize isolated working directories and platform separators automatically
  • Provide explicit timestamp, process ID, and ephemeral-port normalizers
  • Persist complete reproduction diagnostics while keeping successful output concise
  • Cover initial CLI parsing and invocation
  • Cover initial reader behavior and printing
  • Cover namespace creation and switching
  • Cover dynamic Vars and script loading
  • Cover initial error and exit behavior
  • Support interpreted and gobb build compiled programs
  • Generate a website compatibility report with make compat
  • Publish the compatibility summary and full diagnostics in CI

Completed Glojure-native shell

3
Complete

Glojure-native BB execution shell

Replace the host responsibilities that SCI performs inside BB with a Gobb layer built directly on Glojure.

  • Current execution namespace and *file*
  • Standard input, output, and error bindings
  • *command-line-args*
  • Environment and working-directory state
  • Runtime load paths and classpath resources
  • Data readers and default data-reader behavior
  • Preloads and repeated require
  • :bb and :gobb reader features
  • Expression, file, stdin, namespace-main, and exec-function invocation
  • Shutdown hooks and controlled exits
  • Source-aware error formatting without Go panic leakage
  • Native interrupt behavior where supported
  • Runtime and compiled execution agree on namespace, binding, and loader behavior
  • No Gobb-owned runtime source depends on SCI

Completed compatibility inventory

4
Complete

Compatibility ledger and test inventory

Turn BB's complete user-visible surface into a machine-readable backlog before starting the larger feature ports.

  • Inventory BB CLI commands and options
  • Inventory bb.edn, deps.edn, tasks, and exec behavior
  • Inventory bundled namespaces and libraries
  • Inventory BB-exposed Java classes
  • Inventory REPL, pod, server, process, platform, and architecture features
  • Map upstream BB tests and representative programs
  • Assign every item a compatibility state and require test or implementation evidence for support claims
  • Record rationales for intentional differences and platform limits
  • Generate concise Markdown and website reports from the ledger

Completed platform contract

5
Complete

Platform capabilities

Define and test consistent host behavior for native, WASI, and browser-Wasm targets before higher-level libraries depend on it.

  • Define the capability contract and target matrix
  • Classify filesystem, process, environment, clock, random, signal, and network behavior
  • Provide stable host-adapter boundaries for reusable runtime code
  • Return structured unsupported-capability errors
  • Test native, WASI, and browser-Wasm behavior independently
  • Record platform-limited and unavailable behavior in the generated inventory
  • Publish the platform capability matrix

Completed Java compatibility wave

6
Complete

Java compatibility

Implement BB's highest-value exposed Java surface through Glojure, gojava, and reusable Go adapters without introducing a JVM.

  • Rank all 583 exposed classes by pinned BB source, test, and example demand
  • Assign every class to Glojure, gojava, a Go adapter, or an explicit limitation
  • Implement the first java.lang, file, path, and stream wave in Glojure
  • Cover constructors, methods, static fields, catches, and instance checks
  • Add BB/library-shaped Java compatibility fixtures
  • Verify the Glojure bridge across native, WASI, and browser-Wasm builds
  • Update the generated inventory with class-level ownership and evidence

The generated Java compatibility report contains the full ranked ledger. The reusable bridge implementation and its AOT compiler support are tested in Glojure, and Gobb's compiled probe passes under native, WASI, and browser-Wasm.

Completed projects and dependencies

7
Complete

Projects and dependencies

Support the project files and dependency sources that BB uses to build its runtime classpath.

  • Discover and read bb.edn and deps.edn
  • Resolve project paths and recursive local dependencies
  • Resolve pinned Git dependencies into the Gobb cache
  • Resolve source-bearing Maven coordinates and common transitive POM dependencies without a JVM
  • Merge aliases, -Sdeps, and explicit -cp/--classpath entries
  • Load source and non-source resources from the resolved classpath
  • Report precise invalid configuration, coordinate, path, download, and extraction errors
  • Cache dependencies with prepare and inspect them with print-deps
  • Exercise project loading under interpreted and compiled Gobb
  • Run dependency-bearing builds under native, WASI, and browser-Wasm

See Projects and dependencies for discovery, cache, coordinate, build, and target behavior. Maven artifacts must contain portable source; Gobb does not execute JVM bytecode.

Babashka source integration

Gobb builds against Babashka source without vendoring it and without adding Git submodules to this repository.

  • The default build downloads Babashka v1.12.218 at commit 0fb349c414e717800be775ba9cb77c95a9eb700d into the ignored Makes cache.
  • BABASHKA_DIR=/path/to/babashka selects a development checkout instead.
  • Babashka's own submodules will be initialized individually only when a selected capability needs one.
  • A generated source staging tree gives each namespace exactly one provider and rejects duplicates or missing selected files.
  • The machine-readable source ledger currently discovers all 67 core Babashka namespaces: 1 is compiled unchanged, 1 is adapted at staging time, and 65 are deferred pending compatibility work.
  • The upstream proof namespace is babashka.impl.exceptions; the executable entry point is the Gobb-owned gobb.cli.
  • babashka.impl.clojure.main/repl and its binding helper are projected from the pinned source into gobb.bb-repl. The staging ledger records the small set of JVM/SCI-specific adaptations rather than vendoring a fork.

The build interface is now:

make deps           # Download and verify pinned Babashka source
make build          # Build bin/gobb with Gloat
make test           # Run native and differential BB tests
make smoke          # Execute interpreted, native, WASI, and browser-Wasm proof
make capabilities   # Generate the runtime and website platform matrix
make capability-test # Execute the matrix under all three target families
make compat         # Generate the BB-vs-Gobb compatibility report
make test-lib_tests # Run Babashka's library test suite with Gobb
make test-examples  # Compile and exercise Babashka's examples with Gobb
make testing-report # Render committed upstream-suite result snapshots
make inventory      # Generate the complete BB surface ledger and report
make java-compat    # Rank and assign all exposed Java classes
make java-compat-test # Exercise the core class wave on all target families
make repl-wasm      # Build the browser BB REPL with Gloat
make source-ledger  # Print the generated namespace ledger

make clean removes generated source and the Gobb binary. make realclean also removes the downloaded Babashka source checkout.

Known gaps

  • Most Babashka implementation namespaces still depend on SCI, JVM classes, GraalVM substitutions, or libraries that have not been ported.
  • Project-derived classpaths work, but Maven bytecode-only libraries remain unavailable and advanced POM/BOM edge cases are not yet tools.deps-complete.
  • Local EDN pods work, including bb.edn :path coordinates. Registry downloads, socket transport, JSON and Transit payloads, async handlers, and deferred pod namespaces remain.
  • Native terminal editing, nREPL, and socket REPL are implemented. WASI and browser targets still cannot open raw network listeners.
  • Core Ring HTTP serving works through org.httpkit.server; WebSockets, channels, and advanced http-kit options remain.
  • The current source reader wraps input in one do form. Shebang handling and exact BB reader edge cases remain for a later CLI-compatibility pass.

Next concrete slice

Finalize deterministic native and Wasm program builds through Gloat.

Completed tasks and commands

8
Complete

Tasks and commands

Port BB's task model, command selection, exec functions, and process pipelines onto the resolved project basis.

  • Dispatch named tasks and the explicit run command
  • Evaluate global and per-task :init and :requires
  • Order task graphs through :depends
  • Support task arguments, :private, and :doc
  • Run :enter and :leave hooks
  • Implement sequential and parallel task execution
  • Port process invocation and pipelines without JVM process classes
  • Preserve task exit status, streams, environment, and working directory
  • Exercise task and command behavior against pinned BB fixtures

See Tasks and processes for command, graph, hook, parallelism, process-option, and target behavior.

Completed batteries-included wave

9
Complete

Batteries included

Bring over BB's bundled libraries in tested dependency-shaped waves.

  • Port babashka.fs and its filesystem dependency wave
    • Pin and verify the upstream babashka.fs source revision
    • Implement Go-backed core paths, predicates, file I/O, copies, moves, links, and temporary files
    • Differentially test the core filesystem wave against pinned BB
    • Implement recursive visitors, glob and regex matching, and temporary-directory macro compatibility
    • Implement zip, unzip, gzip, and gunzip through Go's archive packages
    • Implement POSIX permission conversion, inspection, mutation, and creation options
    • Classify JVM FileTime-style attributes as a remaining compatibility-closure item
  • Port the public babashka.process API onto the native process adapter
    • Pin and verify the upstream babashka.process source revision
    • Implement tokenization, process, builder, pipeline, sh, shell, and $ entry points
    • Differentially test results, environment, working directory, failures, and pipelines against pinned BB
    • Implement string and byte capture, file redirects, pre-start, exit, and shutdown callbacks
    • Classify direct stream records, true process destruction, and replace-image exec as compatibility-closure items
  • Port curl, HTTP client, and portable networking helpers
    • Pin and verify the upstream babashka.curl source revision
    • Implement native methods, headers, parameters, bodies, redirects, byte responses, and error maps
    • Differentially test file URLs and local HTTP requests without a public network dependency
    • Pin and implement the core babashka.http-client client, method, async, redirect, and function-client surface
    • Record live streaming, custom interceptors, WebSocket, JVM constructors, and browser Fetch as target-specific closure work
  • Fill out clojure.java.io compatibility used by bundled libraries
    • Implement Go-backed files, streams, readers, writers, copying, resources, parents, and deletion
    • Differentially test the core public surface against pinned BB
    • Track all Gobb-owned source namespaces as Make rebuild inputs
    • Record true URL objects, character encodings, and JVM protocol-extension edge cases for compatibility closure
  • Bring over common data libraries for JSON, CSV, YAML, and Transit
    • Pin clojure.data.csv 1.0.0 as the behavioral source reference
    • Implement and differentially test core CSV reading, writing, separators, quoting, and newlines
    • Record alternate CSV quote characters, custom quote predicates, and lazy reads as partial behavior
    • Pin Cheshire 6.2.0 and implement its core JSON parsing, generation, stream, and sequence APIs
    • Record Cheshire factories, custom encoders, Smile, and strict duplicate-key detection as partial behavior
    • Pin clj-yaml 1.0.29 and implement its high-level parsing, generation, key conversion, and multi-document APIs
    • Record SnakeYAML-specific low-level, marked-node, and unsafe Java APIs as non-portable partial behavior
    • Pin transit-clj 1.1.357 and implement common Transit JSON stream values
    • Record Transit cache compaction, custom handlers, tagged values, and non-JSON formats as partial behavior
  • Port CLI, template, logging, and source-rewriting libraries in dependency order
    • Compile pinned external .clj/.cljc source trees without vendoring them into Gobb
    • Pin and differentially test the core babashka.cli 0.8.67 API
    • Pin Hiccup 2.0.0-RC1 and implement core Hiccup/Hiccup2 rendering
    • Record Hiccup page, form, middleware, URI, and compiler optimization APIs as partial behavior
    • Implement and differentially test common tools.logging and Timbre behavior
    • Compile and differentially test pinned Clojure 1.12.4 clojure.zip source
    • Pin rewrite-clj 1.2.54 and assign its Glojure lang.ArityFn AOT blocker to compatibility closure
  • Run each delivered library wave against pinned BB and compiled Gobb
  • Record native, WASI, browser, JVM-only, and compiler-dependent limitations in the generated inventory

Completed website and live Gobb

10
Complete

Website and live Gobb

Publish the tested project state and a real browser-Wasm Gobb experience.

  • Serve the MkDocs site at https://gobb.site/
  • Generate compatibility, inventory, Java, and platform reports from tested ledgers
  • Compile Babashka's reusable REPL loop to browser Wasm with Gloat
  • Provide a responsive terminal-style browser REPL
  • Replay and share complete REPL state through copyable URLs
  • Publish branded, cache-busted social cards
  • Keep make serve, make site, and make publish reproducible

Completed interactive services

11
Complete

Interactive services

Extend Gobb from basic evaluation loops into native interactive and network services while keeping host limitations explicit.

  • Use Glojure's readline terminal with editing, completion, highlighting, and persistent ~/.gobb_history
  • Implement --socket-repl and socket-repl with BB-compatible defaults
  • Implement --nrepl-server and nrepl-server with bencoded evaluation responses
  • Expose programmatic babashka.nrepl.server start and stop operations
  • Expose named clojure.core.server socket REPL lifecycle operations
  • Load, invoke, and unload local EDN subprocess pods
  • Load local :path pods declared in bb.edn
  • Serve Ring handlers through the core org.httpkit.server API
  • Test socket REPL, nREPL, pod, project-pod, and HTTP behavior against real native processes
  • Record registry pods, alternate payload formats, WebSockets, and non-native listeners as explicit compatibility limits

Completed production builds

12
Complete

Production build command

Turn gobb build into a self-contained, reproducible native and Wasm compiler frontend through Gloat.

  • Embed Gobb's selected runtime source graph in the Gobb executable
  • Select the transitive bundled namespace closure required by each program
  • Stage project, dependency, and selected bundled sources together for Gloat
  • Compile and run bundled clojure.java.io and babashka.fs use in native, WASI, and browser-Wasm project tests
  • Allow project namespaces to override bundled namespaces without duplicate inputs
  • Produce byte-identical native builds through managed Gloat 0.1.68
  • Validate target syntax, compiler output, and staging cleanup while retaining native, WASI, and browser-Wasm execution coverage

Completed upstream conformance harness

13
Complete

Upstream conformance harness

Run Babashka's library tests and examples against Gobb, keep complete diagnostics, and publish committed full-suite snapshots.

  • Add a filterable make test-lib_tests target
  • Discover and report the complete upstream library and test-namespace corpus
  • Add the babashka.classpath and babashka.core host namespaces required by the upstream runner
  • Link Glojure's precompiled clojure.test runtime into Gobb
  • Preserve underlying namespace-load diagnostics
  • Compile every upstream .clj example
  • Run safe deterministic examples against BB and Gobb
  • Track explicit environmental and interactive waivers
  • Continue through all library-test and example cases before returning failure
  • Detect additions or removals in the upstream example set
  • Publish current results on the Testing page without rerunning tests

Planned milestones

15

Example-program closure

Close compilation and execution gaps across Babashka's examples and replace temporary waivers whenever portable automation is possible.

16

Final compatibility and release

Close the remaining BB CLI, namespace, Java, and upstream-test gaps, establish performance baselines, and release the full implementation.

What counts as full Gobb?

A release can claim full Gobb status when:

  • applicable user-visible BB tests pass or have documented waivers;
  • every BB-exposed Java class has a compatibility disposition;
  • tasks, dependencies, pods, REPLs, bundled libraries, and build mode have end-to-end coverage;
  • native and Wasm differences are tested and documented;
  • no execution path depends on SCI, a JVM, or GraalVM;
  • this site reflects the tested state of the release.