Skip to content

Roadmap

YAMLStar is developed in phases, each building on the previous work. Here's what's complete, what's in progress, and what's coming next.

Phase 1: Minimal Viable Loader ✅ Complete

Status: Released v0.1.7

Phase 1 delivers production-ready YAML 1.2 loading and dumping with multi-language support.

Completed Features

  • ✅ Pure Clojure YAML 1.2 parser integration
  • ✅ Event-based parsing with 211 grammar rules
  • ✅ 4-stage pipeline (Parser → Composer → Resolver → Constructor)
  • ✅ Dump stack (Representer → Desolver → Serializer → Emitter)
  • ✅ Complete YAML 1.2 Core Schema support
  • ✅ Anchors and aliases
  • ✅ Explicit tags (!!str, !!int, !!float, !!bool, !!null)
  • ✅ Multi-document streams
  • ✅ Comprehensive test suite (23+ tests)
  • ✅ GraalVM native-image shared library
  • ✅ 32 language bindings:
    • Ada
    • Clojure
    • Crystal
    • C#
    • D
    • Dart
    • Delphi (Pascal)
    • Dyalog APL
    • Elixir
    • Erlang
    • F#
    • Fortran
    • Go
    • Haskell
    • Java
    • Julia
    • Kotlin
    • Lua
    • MoonBit
    • Nim
    • Node.js
    • Perl
    • PHP
    • PowerShell
    • Python
    • R
    • Raku
    • Ruby
    • Rust
    • Scala
    • Swift
    • Zig

Architecture

YAML Input
    ↓
Parser (pure Clojure, YAML 1.2)
    ↓
Composer (events → node tree)
    ↓
Resolver (type inference, alias resolution)
    ↓
Constructor (nodes → native data)
    ↓
Output (maps, vectors, scalars)

Key Achievements

  • Zero Dependencies: Only Clojure + data.json (for FFI)
  • 100% YAML 1.2 Compliant: Via reference parser
  • Cross-Language Consistency: Same behavior everywhere
  • Lightweight: ~80% lighter than YAMLScript's pipeline
  • Well-Tested: Comprehensive test coverage
  • Production Ready: Stable API, semantic versioning

Phase 2: Glojure Migration ✅ Complete

Status: Implemented

Phase 2 ports YAMLStar from Clojure/GraalVM to Glojure (Clojure on Go), eliminating the GraalVM dependency from the shared library and improving cross-platform support.

Completed Work

  • ✅ Port core implementation to Glojure
  • ✅ AOT compilation to Go instead of JVM bytecode
  • ✅ Generate Go shared library directly
  • ✅ Preserve the existing C ABI for all language bindings
  • ✅ Eliminate GraalVM native-image from the default shared-library build

Benefits

Simpler Build Process : No more GraalVM installation or native-image compilation. Just Go compiler required.

Smaller Binaries : Go produces smaller binaries than GraalVM native-image.

Faster Builds : Go compilation is significantly faster than native-image.

Better Windows Support : Go has excellent Windows support. No more native-image quirks.

Easier Contribution : Lower barrier to entry for contributors. Standard Go toolchain.

Migration Path

  1. ✅ Prototype: Port parser to Glojure, validate correctness
  2. ✅ Core: Migrate composer, resolver, constructor
  3. ✅ FFI: Preserve the public C API over the Go shared library
  4. ✅ Bindings: Keep the engine change transparent to users
  5. ✅ Build: Make Gloat/Glojure the default for libyamlstar

Backwards Compatibility

The API and behavior will remain identical. Users won't need to change any code. This is purely an implementation detail.

Phase 3: Plugin System 🔮 Future

Target: Q4 2026

Phase 3 will add an extensible plugin system for custom tags, schema validation, and expression evaluation.

Planned Features

Custom Tag Handlers : Register handlers for custom tags like !include, !env, !base64

Schema Validation : Validate YAML against JSON Schema or custom validators

Expression Evaluation : Optional YAMLScript-like features (opt-in)

Directives : Support for %TAG and %YAML directives

Stream Processing : Handle large YAML files incrementally

Plugin Architecture

# Example with custom tags
database:
  password: !env DATABASE_PASSWORD
  config: !include database.yaml
  schema: !validate
    type: object
    properties:
      host: { type: string }
      port: { type: integer }

Plugins will be language-specific modules that hook into the resolver stage:

(yamlstar.core/register-tag
  "!env"
  (fn [node] (System/getenv (:value node))))

Design Principles

  • Opt-in: Core library remains minimal
  • Composable: Mix and match plugins
  • Safe: Plugins are sandboxed by default
  • Portable: Plugin API works across all language bindings

Phase 4: Advanced Features 🌟 Future

Target: 2027

Long-term enhancements for specialized use cases.

Potential Features

  • YAML 1.3 Support: When the spec is finalized
  • Streaming API: Process large documents incrementally
  • Comments Preservation: Retain comments when round-tripping
  • Source Maps: Track line/column info through pipeline
  • Performance Optimizations: Profile and optimize hot paths
  • Additional Bindings: C, C++, Swift, Kotlin, Zig, etc.

Recent Releases

v0.1.7 (June 2026)

  • Add YAML dump stack: representer, desolver, serializer, and emitter
  • Add dump and dump_all APIs to language bindings
  • Add CLI -Y output for emitting YAML
  • Improve block sequence and scalar formatting in emitted YAML

v0.1.2 (January 27, 2026)

  • Add release process and workflow
  • Change npm publishing name to yamlstar
  • Add Clojure library for direct use
  • Add examples for Clojure, Python, Go, Java
  • Refactor binding Makefiles for Windows support
  • Update Maven group to com.yaml
  • Remove SNAPSHOT from shared library name

v0.1.0 (January 10, 2026)

  • Initial release
  • Pure Clojure YAML 1.2 parser implementation
  • Support for scalars, mappings, sequences, anchors/aliases
  • CLI tool for YAML to JSON conversion
  • GraalVM native-image shared library
  • Bindings for 32 languages
  • Auto-installing build system via Makes

Contributing

YAMLStar is open source and welcomes contributions!

How to Help

Report Bugs : Found an issue? Report it at github.com/yaml/yamlstar/issues

Request Features : Have an idea? Open a feature request on GitHub

Write Code : Submit pull requests for bug fixes or new features

Improve Docs : Help make the documentation better

Add Bindings : Port YAMLStar to a new programming language

Write Tests : Expand test coverage with edge cases

Development Setup

# Clone the repository
git clone https://github.com/yaml/yamlstar.git
cd yamlstar

# Run core tests
cd core
make test

# Build shared library
cd ../libyamlstar
make build

# Test a binding
cd ../python
make test

The build system uses Makes to auto-install all dependencies.

Roadmap Discussions

Want to influence the roadmap? Join the discussion on GitHub:

Stay Updated

Support

YAMLStar is open source (MIT License) and maintained by Ingy döt Net and contributors.

For help:

Let's make YAML great again! 🌟