Brocatel Roadmap

v0.X.X

We do not plan to follow Semantic Versioning at this stage, since drastic change in our Markdown grammar is expected (and personally I don't feel like large commits).

v0.1.0

Single-threaded virtual machine implementation:

• VM skeleton with delayed root node loading and array walking capabilities.
• Label and link support in the VM.
  • A label should also serve as a text pointer.
• Global environment and if-else call support.
• Function call support.
• Tagged text support and Gettext API design.
• User input (options) support.
• Save data saving & loading.

v0.2.0

Markdown compiler implementation:

• Plain text nodes.
• Tagged text nodes.
  • Tag data interpolation.
• Links.
  • Compile-time link validity checking.
• Options.
  • Rework to allow show-once options.
• Function calls.
• Labels.
  • Compile-time label validity check: No need since we check links?
• Macros.
• Debug info generation.

v0.3.0

Runtime API design.

• API naming convention (maybe all-capital to avoid name conflicts with user labels): ALL CAPITALS & some Lua reserved words.
  • Make API values read-only.
  • More API.
    • BREAK or EXIT or END for loops.

      :::loop `loop_name`
      - A
        `END(loop_name)`

      • Syntax sugar: --- for END() (we are going to use it for function calls)
    • Search for TODO in arch.md.
• IP (instruction pointer) access.
• Label access counter.
  • Label fuzzy lookup.

    # Markdown Examples
    [](#markdown-examples)

    (This allows running README.md from most repositories.)
  • Exclude normal links like [Wikipedia](https://...).
• Show-once options, show-forever options and show-N-times options.
  • Data save API (allow functions to attach data to the current IP or any path).
• Add caching layer.
  • Cache output to provide idempotency.
  • Cache user input.
• IFID: use frontmatter to include IFIDs for stories.

Integration examples

• Save & load.
  • API.
  • Examples? Or detailed Lua documentation.
• Export read counts along with the lines to let the user / the outer game engine decide whether to skip lines (or even display some relevant text / highlighting).
• Complete porting The Intercept, which is a little bit lengthy.

v0.4.0

Multi-thread (not those threads) support:

• Multi-thread API design.
  • Replace the quote grammar (> text) with a macro (maybe named then?).
  • Use > to signify thread-related operations.
• Multi-thread API implementation and thread-local variable support.
• Story call and local variable support.
  • Function stack: call and return.
  • Tail call support: jump to elsewhere, popping up a stack frame.
  • Compiler error: forbid jumping from inside of a function.
• Coroutine support.
  • What about structured concurrency?

Some clarifications:

• With threads, you may build games (with lots of tweaks, of course) like 428: Shibuya Scramble, where multiple threads of stories interweaves.
• With coroutines, you may construct conversations where people talk about multiple things simultaneously, just like threads in Ink.
• Story calls are just function calls for plots.

v0.5.0 and on

Bug fixes and Markdown grammar optimization.

Documentation, tutorials, etc.

• Porting The Intercept.
• Porting Cloak of Darkness.
• Follow suit: Tutorial for Ink (better still if interactive).
• IDE implementation (or probably just a VS Code plugin with language server protocol implementation).
  • Simplistic LSP implementation detecting compilation errors.
  • Using Lua LSP for Lua checking & completion.
  • Executing stories right from VS Code.
    • Highlighting runtime errors in the Markdown source code.
  • Simplistic debugging interface by implementing the Debug Adapter Protocol.
    • Stepping.
    • Breakpoints.
    • Pause/continue/stop/restart.
    • Lua variables.
  • Allow exporting stories into a single web page to be exported online.
• Frontend implementation, so that one can easily publish their IF online.
  • Choice-based stories.
  • A bit parser-like frontend.

v1.0.0

Let's start Semantic Versioning.