johnynek/bosatsu

Bosatsu is a polyglot programming language and compiler toolchain that transpiles source code to JVM, JavaScript, Python, and C targets. It provides a comprehensive standard library, a CLI for type checking and evaluation, and a web-based playground for interactive code execution. The system includes robust infrastructure for cross-platform I/O, protobuf integration, and performance benchmarking, supported by machine-checked proofs for its evaluation semantics.

This change introduces a new set of Bosatsu source files that model GitHub Actions workflows as data structures. The \Util.bosatsu\ module provides a shared library of structs (such as \Step\, \Workflow\, and \StepEnv\) and constants for runners, Java versions, and actions, serving as the foundation for the workflow definitions. The \Ci.bosatsu\, \CodecovMain.bosatsu\, \DeployWeb.bosatsu\, and \Release.bosatsu\ files define specific CI/CD pipelines, including test execution, coverage reporting, web deployment, and release builds. Additionally, a new \ConfigDemo.bosatsu\ example demonstrates encoding Protobuf wire format data using the Bosatsu IO and Proto libraries.

_test\workspace/Bosatsu/Example · high confidence

Introduces a new CLI command for managing the C runtime, allowing users to download, verify, and extract the runtime archive. The command supports specifying a local archive path or a remote URL with a Blake3 hash for integrity verification, and automatically detects the repository root via .git if not explicitly provided.

core/src/main/scala/dev/bosatsu/cruntime · high confidence

Introduces new CLI benchmarking utilities (CheckBenchmarkMain and EvalBenchmarkMain) for performance profiling of the compiler and evaluator, and adds a new Scala.js platform implementation for the core IO runtime (PredefIoCorePlatform) to enable filesystem and process operations in Node.js environments.

repository · high confidence

The test\_workspace directory now includes a wide range of Bosatsu source files serving as both examples and regression tests. These additions cover fundamental data structures (AvlTree, BinNat, BinInt, Queue, TreeList), functional programming concepts (Applicative, Traverse, Lazy, Eval), and standard library utilities (Char, Float64, Int64, Json, Bool). The suite also introduces property-based testing for Int64 arithmetic laws and specific runtime edge cases for large integer operations, alongside practical examples like Project Euler problems and build system configurations.

_test\workspace · high confidence

This change introduces a new in-repo Tree-sitter grammar for the Bosatsu language, enabling syntax highlighting, folding, and basic token recognition in Neovim via nvim-treesitter. The grammar defines keywords (including \matches\), identifiers, operators, punctuation, and structural elements like package declarations, function definitions, and control flow constructs. It also includes a custom external scanner to handle indentation-based block structure and a set of Neovim configuration files to register the parser. This provides foundational syntax support for Bosatsu files within the editor.

syntax/tree-sitter-bosatsu · high confidence

Users can now generate Bosatsu code from .proto files using a new protoc plugin (ProtocPluginNodeMain) and utilize the generated code with a new runtime library for encoding and decoding protobuf wire formats. The core module includes ProtoNaming for generating safe Bosatsu identifiers from proto definitions, and the test workspace includes Wire.bosatsu which implements the low-level binary serialization logic (varints, fixed32/64, length-delimited fields) required for the protobuf wire protocol.

_cliJS/src/main/scala/dev/bosatsu/protobuf, core/src/main/scala/dev/bosatsu/protobuf, test\workspace/Bosatsu/Proto · high confidence

The library now includes derived JSON readers and writers for \LibDescriptor\, \LibHistory\, and lists of \LibDependency\. This enables these core library metadata structures to be serialized to and deserialized from JSON format, facilitating configuration storage or API exchange. The \Library\ object also provides helper methods for constructing and inspecting these dependency structures.

core/src/main/scala/dev/bosatsu/library · high confidence

A new JMH-based benchmark class (TestBench) has been added to the bench module to measure the performance of the compiler's evaluation engine. It includes specific benchmarks for a Gauss summation workload (testing sizes 10 and 20) and an Euler4 palindrome product workload, allowing users to track regression or improvement in execution speed for these representative cases.

bench/src · high confidence

The C runtime is now available as a first-class platform, providing a complete build infrastructure via a new Makefile that supports debug and release profiles (defaulting to -O3 -flto) and integrates with the Boehm garbage collector and libuv. This release includes the core runtime implementation, generated type declarations, and external bindings for Bosatsu's standard library modules, including Predef, Prog, IO (Core and Bytes), Collection (Array), Num (Float64 and Int64), Lazy, and Eval. A benchmark suite and a Boehm GC example are also included to demonstrate performance and memory management capabilities.

_c\runtime · high confidence

This change introduces the foundational \dev.bosatsu.smt\ package, providing core utilities for working with SMT-LIB scripts. It adds \SmtLibRender\ to convert internal SMT expressions, commands, and scripts into SMT-LIB formatted text, and \SmtToSExpr\ to handle the underlying syntax tree transformations. Additionally, \SmtScriptScope\ is included to analyze scripts for undeclared variables, ensuring that all references in assertions and defined functions are properly scoped.

core/src/main/scala/dev/bosatsu/smt · high confidence

The jsui module has been initialized with a new HTML entry point (index.html) that loads the Bosatsu UI application. A new CSS file (app.css) defines a responsive grid layout for the interface, splitting the view into code and output sections with specific styling for text areas and grid items. Additionally, a webpack configuration (webpack.config.js) has been added to handle the Scala.js bundle, specifically excluding the generated Scala.js bundle from source-map-loader rules to prevent build errors and disabling Node.js built-in modules (fs, path, os, crypto, perf\_hooks) in the browser environment.

jsui · high confidence

Users can now install the Bosatsu extension for Visual Studio Code to get syntax highlighting for .bosatsu files. The extension provides basic TextMate grammar support for keywords, functions, structs, enums, comments, numbers, strings, character literals, and string interpolation (${...} and $.{...}). It also includes language configuration for auto-closing pairs and brackets. Note that this is a syntax-only feature with no semantic tokens, and type/constructor highlighting is capitalization-based.

syntax/vscode · high confidence

This change establishes the foundational structure for the Bosatsu project, introducing the \bosatsu\ CLI wrapper script that manages platform-specific artifacts (Java, Node, native) and a \bosatsuj\ launcher for the JVM assembly. It adds build and CI configuration files including \.travis.yml\ for Scala 2.12/2.13 and JS testing, \.bazelrc.travis\ for Bazel memory and sandbox settings, and \.scalafmt.conf\ to enforce Scala 3 formatting with version 3.10.7. The repository also includes a \LICENSE\ (Apache 2.0), \README.md\ with an example program, and a suite of test scripts (\test\_cli.sh\, \test\_python.sh\, \testc\) to validate CLI, Python transpilation, and C transpilation workflows respectively.

(repo-wide) · high confidence

This change adds a new \Bosatsu/Collection/Array\ module that defines an external \Array\ type and exposes a comprehensive set of operations including creation (\empty\, \tabulate\, \from\_List\), access (\get\, \set\, \slice\), transformation (\map\, \filter\, \flat\_map\, \reverse\, \flatten\), and reduction (\foldl\, \foldr\, \sumf\, \dotf\). It also provides conversion helpers between Arrays and other types such as \List\, \String\, and \Char\, leveraging \Int64\ for indexing. The module includes property-based tests to verify correctness against list-based implementations.

_test\workspace/Bosatsu/Collection · high confidence

The Bosatsu/IO package is now available, providing a structured API for input and output operations. This includes a \Bytes\ type for binary data handling with UTF-8 conversion, a \Core\ module for file system operations (reading, writing, temp files, directories), and process management capabilities (spawning, waiting, terminating). Standard I/O helpers (\Std\) are also included for console interaction, all built on the \Prog\ effect system for error handling.

_test\workspace/Bosatsu/IO · high confidence

The \core/src/main/resources/bosatsu/predef.bosatsu\ file now provides the core standard library for the Bosatsu language, defining fundamental types such as \Bool\, \Char\, \Int\, \Float64\, \List\, \String\, \Dict\, and tuples up to arity 32. It also exports a comprehensive set of built-in functions for arithmetic, list manipulation, string processing, and dictionary operations, establishing the baseline API available to all Bosatsu programs.

core/src/main/resources · high confidence

The tool now supports serializing and deserializing internal data structures using the EDN (Extensible Data Notation) format. This change adds a new \Edn\ AST and a generic \EdnCodec\ trait in the \dev.bosatsu.edn\ package, enabling lossless round-trip encoding between EDN and JSON for library show outputs. Additionally, the \CommandSupport\ module has been updated to handle dependency package base URLs and validate distinct package names, while \CommonOpts\ exposes new command-line options for cache directories and dependency paths, and \LintMode\ introduces strict, warn, and lax linting levels.

core/src/main/scala/dev/bosatsu/tool · high confidence

The core hashing module now provides a \Hashable\ typeclass that enables automatic derivation of hash implementations for case classes, enums, and other algebraic data types using Scala 3's inline and macro features. This allows users to generate consistent hashes for complex structures without writing manual hashing logic, supporting nested types and standard library collections through derived instances.

core/src/main/scala/dev/bosatsu/hashing · high confidence

Added a new \Fs2PlatformIO\ implementation in the \dev.bosatsu\ package to handle platform-specific I/O operations for the Scala.js target. This component provides concrete implementations for file system interactions (using fs2), process execution, environment variable access, and temporary directory management, enabling the CLI tool to function correctly in JavaScript environments.

cliJS/src/main/scala/dev/bosatsu · high confidence

This change adds the Scala.js-specific implementations of core platform abstractions, enabling the Bosatsu compiler to run in JavaScript environments. It introduces \BosatsuInt\ to handle integer arithmetic with automatic fallback to \BigInteger\ for values outside the 32-bit range, \Par\ to provide a no-op parallelism layer compatible with Scala.js limitations, \Platform\ to detect the operating system in Node.js or browser contexts, and \StackSafe\ to catch JavaScript-specific stack overflow errors. These components replace or complement the JVM-specific logic, ensuring the core language runtime functions correctly on the Scala.js target.

core/.js/src/main · high confidence

The core type environment now explicitly supports type aliases and structured constructor management. Users can define and reference type aliases within packages, and the system tracks constructors alongside their defining types, enabling more precise type resolution and representation for defined types and their associated functions.

core/src/main/scala/dev/bosatsu/rankn · high confidence

The compilation pipeline now supports a persistent filesystem cache for compiled packages. This change introduces a new caching abstraction (InferCache) and a concrete filesystem implementation (CompileCache) that stores compiled artifacts using content-addressable storage (CAS) keyed by Blake3 hashes. The cache keys incorporate the source hash, dependency interfaces, compiler identity, and enabled typed passes to ensure correctness. Compiled artifacts are returned with region tags, allowing the system to skip parsing and inference on cache hits by using raw source hashes. The cache directory can be configured via a compile option, and stats are available via an environment variable.

core/src/main/scala/dev/bosatsu/cache · high confidence

A new protobuf definition file (TypedAst.proto) has been added to establish the serialized structure for the compiler's typed abstract syntax tree. This schema defines the data models for core type system components, including type kinds, variance, type variables, universal and existential quantification, type application, and type aliases. It also formalizes the structure for defined types, constructors, function parameters with default bindings, and package interfaces, providing the foundational format for exchanging typed AST data between compiler stages or external tools.

proto · high confidence

This change introduces new core capabilities for the library: a compile-time macro in \dev.bosatsu.Macro\ that allows loading file contents as string literals during compilation, and a new pattern-matching framework in \dev.bosatsu.pattern\ consisting of \Matcher\ and \Splitter\ traits. The \Matcher\ trait provides a generic interface for matching elements with support for mapping results and specific matchers for equality, integers, and boolean functions. The \Splitter\ abstract class and its implementations (including \stringSplitter\ and \listSplitter\) enable splitting sequences (strings and lists) based on these matchers, handling code points correctly for strings and supporting monoidal accumulation of results.

base, core/src/main/scala/dev/bosatsu/pattern · high confidence

The \lean\_proofs\ directory now contains machine-checked Lean proofs demonstrating that extending structural descent with trusted thunk and lazy force steps preserves well-foundedness (\TrustedForceProjection\). It also proves that adding trusted \Eval::eval\ steps remains well-founded and that the \flat\_map\ callback binder correctly projects to the evaluated input (\TrustedEvalProjection\). Additionally, it provides a fuel-free evaluator implementation (\EvalNoFuel\) using a static work-bound measure to prove termination, alongside proofs for a naive \Eval\ model showing that semantic termination implies the existence of finite fuel (\EvalFuelExistence\).

_lean\proofs · high confidence

The repository now includes a suite of new scripts in the \scripts/\ directory to support C backend testing, library publishing, and release verification. \scripts/test\_c\_sanitizers.sh\ and \scripts/test\_c\_valgrind.sh\ run the C backend tests under AddressSanitizer/UBSan and Valgrind memory checks, respectively, ensuring memory safety of generated C code. \scripts/publish\_bosatsu\_libs.sh\ automates the publishing of Bosatsu libraries with optional dry-run support, while \scripts/c\_runtime\_ci\_env.py\ validates and exports the environment for vendored C runtime dependencies (libuv, libgc). Additional scripts include \scripts/test\_launcher\_passthrough.sh\ to verify argument passing, \scripts/test\_tree\_sitter.sh\ for grammar validation, \scripts/verify\_release\_tag.py\ to ensure sbt version tags match git tags, and \scripts/test\_basic.sh\ for basic batch testing.

scripts · high confidence

The jsapi module now exposes a \Bosatsu\ object to JavaScript environments, providing \evaluate\ and \evaluateJson\ methods. These functions allow external applications to execute Bosatsu code by passing source files and a main package or file path, returning results as rendered HTML strings or JSON-compatible objects. This enables integration of Bosatsu evaluation capabilities into web demos and other JavaScript-based tooling.

jsapi · high confidence

The library now includes new core components for graph operations: a \Dag\ trait with methods for layer calculation, topological sorting, and cycle detection via \dagify\ and \transitiveSet\; a \Paths\ object providing functions to enumerate all simple paths and cycles between nodes; and a \CanPromise\ trait to support lazy, effectful computation patterns. These additions enable users to perform structural analysis and traversal on directed acyclic graphs and general graphs within the core library.

core/src/main/scala/dev/bosatsu/graph · high confidence

Added \Relatable\ and \SetOps\ traits in the \dev.bosatsu.set\ package to support advanced set-relation logic and pattern-matching operations. \Relatable\ defines how two values relate (e.g., Same, Sub, Super, Intersects, Disjoint) and provides implementations for standard Scala Sets and list-based unions. \SetOps\ extends this with set-algebraic operations like intersection, difference, and unification, specifically supporting \missingBranches\ and \unreachableBranches\ calculations to aid in exhaustiveness checking and pattern coverage analysis.

core/src/main/scala/dev/bosatsu/set · high confidence

The Scala source file \src/main/scala/example/Hello.scala\, which contained the implementation of a Hindley-Milner type inference engine (including type definitions, expression structures, and the inference logic itself), has been deleted from the project.

src/main · high confidence

The CLI now uses a new \Main\ object that initializes the application with the CPU starvation checker disabled to prevent performance issues in long-running processes. It delegates execution to \PathModule\, which wires the core logic to a new \IOPlatformIO\ implementation. This platform layer provides the concrete \cats.effect.IO\ operations for file system access, environment variables, and system command execution, ensuring the CLI runs correctly on the target platform.

cli/src/main · high confidence

The core source files have been moved to the dev.bosatsu package and refactored to include several new utility modules: CollectionUtils for handling unique keys in collections, DirectEC for a direct execution context, EditDistance for calculating string similarity, Fix for opaque fixed-point recursion, IorMethods for converting Ior to Validated, ListOrdering for comparing lists, ListUtil for optimized list operations, MainModule for the CLI tool entry point, MatchlessFromTypedExpr for compiling matchless expressions, Nullable for opaque nullable types, PackageCustoms for package import/export validation, ParallelViaProduct for parallel execution, ParserHints for improved parse error messages, Region for opaque region tracking, Require for macro-based requirements, StringUtil for string parsing and escaping, TypeParser for type parsing, TypeRefConverter for type reference conversion, and Writer for an optimized writer monad.

core/src/main/scala/dev/bosatsu · high confidence

The CLI entry point now disables the CPU starvation checker by setting the initial delay to infinity. This behavioral change prevents the runtime from interrupting or flagging long-running CLI processes as starved, ensuring smoother execution for tools that may legitimately hold CPU resources for extended periods.

cliJS/src/main/scala/dev/bosatsu/tool · high confidence

The code generation core now utilizes a new \CompilationNamespace\ and \CompilationSource\ architecture to manage the Matchless IR compilation process. This change introduces support for global inlining and configurable local pass options, allowing the compiler to optimize code structures more effectively. Additionally, new utilities for identifier escaping (\Idents\) and a generic \Transpiler\ trait are added to handle output rendering and argument parsing, forming the foundation for the updated Matchless IR support.

core/src/main/scala/dev/bosatsu/codegen · high confidence

The web interface has been rewritten using the ff4s framework to provide a playground for Bosatsu code. Users can now enter code snippets and trigger three distinct actions—evaluate, test, and show—via dedicated buttons. These actions are routed through the underlying tooling (using the 'tool' prefix commands) to produce HTML-colored output, which is displayed in an output panel along with execution duration. The UI automatically manages state persistence in the browser's local storage and injects a default package name for snippets that lack an explicit header, ensuring seamless execution in the web demo environment.

jsui/src/main · high confidence

This change introduces platform-specific implementations for the JVM target, replacing generic or cross-platform logic with optimized JVM-native code. It adds a new \BosatsuInt\ type that uses \Long\ for performance and falls back to \BigInteger\ for arbitrary-precision arithmetic, ensuring correct behavior for large integers. A new \Par\ object provides parallel computation support using Scala \Future\ and \ExecutionContext\, enabling concurrent operations on the JVM. The \Platform\ object now exposes JVM-specific constants and OS detection. Runtime I/O and file system operations (such as reading/writing files, spawning processes, and managing directories) are wired to JVM-native implementations via \PredefIoCorePlatform\. Additionally, stack-safety is improved with a \StackSafe\ utility to catch \StackOverflowError\, and a \Sha256Hash\ utility is added for cryptographic hashing.

core/.jvm/src/main · high confidence

The \bosatsu tool\ command-line interface has been significantly restructured, replacing the previous command set with a new suite of subcommands: \check\ (type checking), \test\ (test discovery and execution), \transpile\ (code generation to Python/Clang), \json\ (JSON/YAML evaluation and traversal), \doc\ (markdown documentation), \eval\ (expression evaluation with optional \--run\ mode), \deps\ (dependency graph output), \show\ (IR/typed expression display), \assemble\ (library assembly), \extract-iface\ (interface extraction), and \protoc-plugin\ (protobuf code generation). This refactor enforces stricter dependency visibility rules, requiring that dependencies used in \assemble\ operations be full \.bosatsu\_lib\ files rather than interface-only \.bosatsu\_ifacelib\ files, and introduces explicit public/private dependency separation across commands. Users will now interact with a more granular, workflow-oriented CLI that supports features like YAML output for JSON commands, \--run\ passthrough arguments for evaluation, and compile caching.

_core/src/main/scala/dev/bosatsu/tool\command · high confidence

Add end-to-end C code generation tests; Add property-based tests for Python code generation; Add test coverage for Int64 runtime, Array operations, and compiler internals; Added CLI test coverage for JSON parity, IO platform, and Protobuf plugin; Added JVM integration tests for IO, Z3, and Tree-sitter; Added JVM tests for Python code generation and Array runtime; Added regression tests for JSUI state serialization and Store command handling; Added tests for C runtime dependency manifest validation; Added tests for Fs2PlatformIO path resolution; Added tests for Node.js IO core functionality; Added tests for core\_alpha library configuration exports; Removed obsolete type inference tests.

The project's build system has been significantly updated: the sbt version is bumped from 0.13.16 to 1.13.0, and the plugin configuration in project/plugins.sbt is refreshed with current versions for tools like sbt-assembly (2.5.0), sbt-scalajs (1.22.0), and sbt-scoverage (2.4.4). Additionally, the dependency definitions in project/Dependencies.scala have been migrated to use Scala 3-compatible cross-building syntax (Def.setting with %%%) and updated to newer library versions, such as cats-effect 3.7.1, cats-parse 1.1.0, and protobuf-java 4.36.1.

project · high confidence

The project has upgraded its primary language version from Scala 2.13 to Scala 3.8.2, enabling strict equality checks and modern compiler warnings. The build system has been restructured to support cross-compilation to both JVM and JavaScript platforms using sbt cross-project, replacing the previous single-platform setup. Additionally, new npm package manifests have been added for the tree-sitter grammar and VS Code extension, and the JavaScript build tooling now includes a \package-lock.json\ with pinned versions for Webpack and related dependencies.

(dependencies) · high confidence

An empty file named .attach\_pid26384 was added to the bench directory. This file appears to be a transient artifact, likely created by a Java attach mechanism or diagnostic tool, and has no functional impact on the product.

bench · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 48.

• Code Health 73
• Architecture 98
• Maturity 77
• Readiness 58
• Security 54
• Accessibility 33

• 300 commits — 262 feature/other, 38 fixes

• core/src — 147 commits
• docs/design — 38 commits
• test_workspace/core_alpha_conf.json — 27 commits
• project/Dependencies.scala — 24 commits
• project/plugins.sbt — 13 commits
• docs/code-plans — 10 commits
• project/build.properties — 9 commits
• cli/src — 6 commits
• test_workspace/Bosatsu — 6 commits
• (root) — 4 commits
• docs/roadmap — 3 commits
• syntax/tree-sitter-bosatsu — 3 commits
• core/.jvm — 2 commits
• docs/src — 2 commits
• .github/workflows — 1 commit
• c_runtime/Makefile — 1 commit
• c_runtime/bosatsu_ext_Bosatsu_l_Collection_l_Array.c — 1 commit
• jsui/webpack.config.js — 1 commit
• test_workspace/BinNat.bosatsu — 1 commit
• test_workspace/PredefTests.bosatsu — 1 commit

• fix: Add launcher regression test for eval passthrough (#2184)
• fix: Add parser hint for missing trailing expression after nested def (fix #2020) (#2022)
• fix: Add process stop cleanup regression coverage (#2377)
• fix: Add regression tests for package-local nested match normalization (#2269)
• fix: Add unexpected-indentation parse hint and regression test for #2028 (#2029)
• fix: Export max_Char from Bosatsu/Char and add issue #1952 regression (#1954)
• fix: Fix #2034: enumerate and summarize aggregated compiler diagnostics (#2037)
• fix: Fix #2082: avoid StackOverflowError in source-conversion type quantification (#2085)
• fix: Fix #2087 by treating Unit lambdas as suspension boundaries in normalization (#2090)
• fix: Fix #2169: clearer lib test --filter typo error with package suggestions (#2175)
• fix: Fix Int recursion fallthrough for subsuming guarded patterns and support direct predef operator aliases (#1985)
• fix: Fix Int recursion guard fallthrough for irrefutable constructor patterns (#1970)
• fix: Fix Python intrinsic lambda emission scope leak; add issue #1961 regression (#1962)
• fix: Fix RingOpt +0 normalization root stripping and add issue #1997 regression (#1999)
• fix: Fix lib test --filter hiding compile errors as "no tests found" (#2176)
• fix: Fix circular dependency diagnostics to report canonical minimal cycles (#2117)
• fix: Fix cross-package arity mismatch error context output (#2115)
• fix: Fix guarded list search lowering (#2214)
• fix: Fix instantiation round-trip property quantifier scope (#2429)
• fix: Fix int64 min literal emission in ClangGen and add C11-safe regression test (#2113)
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

johnynek/bosatsu was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.