blade-ink-rs - GitLite

KO | EN

gitlite — search

#javascript #hacktoberfest #typescript #llm #android #machine-learning #rust #deep-learning #nodejs #windows #kubernetes #awesome-list #mcp #ios

blade-ink-rs

(★ 80)

Inkle Ink runtime implementation in Rust

File Explorer

Download Latest Version (.zip)

- devcontainer.json
- Dockerfile
- - ci.yml
  - publish.yml
- launch.json
- settings.json
- - ast.rs
  - consts.rs
  - error.rs
  - includes.rs
  - inline.rs
  - lib.rs
  - stats.rs
- - compiler_tests.rs
- Cargo.toml
- - test1.ink
  - test1.ink.json
  - TheIntercept.ink
  - TheIntercept.ink.json
- - basic_text_test.rs
  - choice_test.rs
  - conditional_test.rs
  - divert_test.rs
  - function_test.rs
  - gather_test.rs
  - glue_test.rs
  - knot_test.rs
  - list_test.rs
  - misc_test.rs
  - multi_flow_test.rs
  - runtime_test.rs
  - stitch_test.rs
  - tag_test.rs
  - the_intercept_test.rs
  - thread_test.rs
  - tunnel_test.rs
  - variable_test.rs
  - variable_text_test.rs
- Cargo.toml
- - compiler_tool.rs
  - main.rs
  - player.rs
- - basic_tests.rs
  - test_the_intercept.rs
- Cargo.toml
- - callstack.rs
  - choice.rs
  - choice_point.rs
  - container.rs
  - control_command.rs
  - divert.rs
  - flow.rs
  - glue.rs
  - ink_list.rs
  - ink_list_item.rs
  - lib.rs
  - list_definition.rs
  - list_definitions_origin.rs
  - native_function_call.rs
  - object.rs
  - path.rs
  - pointer.rs
  - push_pop.rs
  - search_result.rs
  - state_patch.rs
  - story_error.rs
  - story_state.rs
  - tag.rs
  - value.rs
  - value_type.rs
  - variable_assigment.rs
  - variable_reference.rs
  - variables_state.rs
  - void.rs
- Cargo.toml
.gitignore
AGENTS.md
Cargo.toml
LICENSE
README.md
rust-toolchain.toml

# Installation Guide

1. Get the code

git clone https://github.com/bladecoder/blade-ink-rs

Downloads the entire project code from GitHub to your computer.

cd blade-ink-rs

Moves into the project folder you just downloaded.

2. Official Install Script

Easy Recommended

Prerequisites

Rust (rustup) Rust is required to use cargo.

cargo install rinklecate

Builds and installs the package published on crates.io — no need to clone the repo yourself.

✅ After installing, open a new terminal and run the program's version command (e.g. --version) to confirm it worked.

Pulled directly from this repo's README.

3. Rust

Medium

Prerequisites

Git Needed to download the project code from GitHub.
Rust (rustup) Installing via rustup also installs cargo.

cargo install rinklecate

Builds and installs the package published on crates.io — no need to clone the repo yourself.

✅ If cargo build finishes without errors, it worked. The executable is created under target/.

Pulled directly from this repo's README.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Blade Ink
This is a Rust port of Inkle's [Ink](https://github.com/inkle/ink), a scripting language for writing interactive narratives.

`bladeink` is fully compatible with the reference version and supports all its language features.

To learn more about the Ink language, you can check [the official documentation](https://github.com/inkle/ink/blob/master/Documentation/WritingWithInk.md).

## Crates

| Crate | Description |
|---|---|
| [`bladeink`](https://crates.io/crates/bladeink) | Runtime library — load and play compiled `.ink.json` stories |
| [`bladeink-compiler`](https://crates.io/crates/bladeink-compiler) | Compiler library — compile `.ink` source files into `.ink.json` |
| [`rinklecate`](https://crates.io/crates/rinklecate) | CLI tool — compile and play Ink stories from the command line |

## Using the `bladeink` runtime crate

Here is a quick example that uses basic features to play an Ink story using the `bladeink` crate.

```rust
// story is the entry point of the `bladeink` lib.
// json_string is a string with all the contents of the .ink.json file.
let mut story = Story::new(json_string)?;

loop {
    while story.can_continue() {
        let line = story.cont()?;

println!("{}", line);
    }

let choices = story.get_current_choices();
    if !choices.is_empty() {
        // read_input is a method that you should implement
        // to get the choice selected by the user.
        let choice_idx = read_input(&choices)?;
        // set the option selected by the user
        story.choose_choice_index(choice_idx)?;
    } else {
        break;
    }
}
```

The `bladeink` library supports all the **Ink** language features, including threads, multi-flows, variable set/get from code, variable observing, external functions, tags on choices, etc. Examples of uses of all these features can be found in the `conformance-tests/tests` folder in the [source code](https://github.com/bladecoder/blade-ink-rs/tree/main/conformance-tests/tests).

## Using the `bladeink-compiler` crate

The `bladeink-compiler` crate compiles `.ink` source files into the JSON format expected by the runtime.

```rust
use bladeink_compiler::compile;

let ink_source = std::fs::read_to_string("my_story.ink")?;
let json = compile(&ink_source, None, None)?;

// json is a String with the compiled .ink.json content
let mut story = bladeink::story::Story::new(&json)?;
```

## Running Ink stories with *rinklecate*

`rinklecate` is a command-line tool that mirrors the interface of the official `inklecate` tool. It can compile `.ink` source files and optionally play them directly in the terminal.

You can install it from crates.io:

```bash
cargo install rinklecate
```

### Usage

```
rinklecate <options> <ink file>
   -o <filename>   Output file name
   -c              Count all visits to knots, stitches and weave points
   -p              Play mode
   -j              Output in JSON format (for communication with tools like Inky)
   -s              Print stats about story including word count
   -v              Verbose mode — print compilation timings
   -k              Keep rinklecate running in play mode even after story is complete
   -x <directory>  Import plugins (accepted but ignored — not supported)
```

### Examples

Compile an `.ink` file to `.ink.json`:

```bash
rinklecate my_story.ink
```

Compile and play immediately:

```bash
rinklecate -p my_story.ink
```

Play an already compiled story:

```bash
rinklecate my_story.ink.json
```

In the `inkfiles` folder you can find many Ink test stories to explore the language capabilities, including **The Intercept**, a full featured story created by **Inkle**:

```bash
rinklecate -p inkfiles/TheIntercept.ink.json
```

## Using Blade Ink in C

There are C bindings available to use Blade Ink in your C projects. Check it out [here](https://github.com/bladecoder/blade-ink-ffi).