inkle/ink

Features

• Branching Narrative Engines - Provides a specialized scripting language and engine for authoring interactive stories with non-linear paths and choices.
• Narrative Runtime Execution - Executes compiled story files to manage narrative state and drive the interactive user interface.
• Declarative Narrative Scripting - Implements a specialized declarative scripting language that compiles to bytecode for defining interactive narratives and game logic.
• Branching Narrative Design - Defines player choices that diverge the narrative flow and can later converge at common points.
• Section-Based Organization - Organizes stories into named sections to enable non-linear flow and complex branching paths.
• Flag-Based Story Branching - Manages narrative progression and world state using variables and visit counters with support for serialized state saving.
• Narrative Diversions - Directs narrative progression through diverts to jump between sections and convergence points after branching.
• Narrative Bytecode Compilation - Transforms raw interactive scripts into a machine-readable JSON bytecode format to optimize execution within external game engines.
• Inline Variable Interpolation - Allows variables and logic to be evaluated inline within text to create reactive and dynamic dialogue.
• Interactive Choice Types - Implements various interactive choice types, including one-time, repeatable, and fallback options to drive the narrative.
• Attribute State Tracking - Manages multi-valued states using list operations to track a wide variety of player attributes.
• Dialogue Authoring Tools - Provides a specialized toolset for authoring complex conversational flows with conditional logic and state-dependent responses.
• Dialogue Choice Systems - Provides a system for creating complex conversation trees with nested choices and conditional responses.
• Game State Management - Tracks world properties, player progress, and visit counters to drive complex narrative logic.
• Game State Variables - Tracks world properties and player progress using global variables, scratch variables, and constants to drive narrative logic.
• Host Engine Callbacks - Provides a way for narrative scripts to trigger specific game logic and external functions in the host engine.
• Section-Based Flow Control - Directs narrative progression by jumping between named content blocks and managing return paths.
• State-Based Narrative Engines - Connects compiled narrative scripts to game engines to trigger external logic and render text via custom interfaces.
• Conditional Text Display - Displays specific text or dialogue options based on logical tests and previous story visits.
• Foreign Function Bindings - Allows script-defined functions to be bound to native game logic functions.
• Script Variable Management - Implements a system for defining and managing script variables and registering observers to trigger logic on value changes.
• State Serialization - Serializes the current narrative state to a string and restores it later to resume game progress.
• Conditional Rendering Logic - Displays text and choices by evaluating global variables and visit history against logical expressions.
• Dialogue Sequence Control - Displays different text variations on repeat visits using sequences, cycles, or randomized shuffles.
• Concurrent Narrative Paths - Splits the story into simultaneous sub-sections to handle concurrent player actions or environmental events.
• Point Labeling - Provides unique identifiers for choices and convergence points to track player decisions and manage story jumps.
• Reusable Segments - Implements reusable narrative sections that can be invoked from multiple points in a story and return to the original context.
• Visit-State Conditionals - Displays specific text or unlocks choices based on the player's history of visiting labeled story points.
• Prose Variation Systems - Cycles through text alternatives or uses random shuffles to ensure prose remains varied and non-repetitive.
• Content Metadata Tagging - Adds invisible tags to text lines that trigger specific behaviors or visual changes in the engine.
• Metadata Tagging - Embeds invisible markers within text to signal systemic or visual actions to the host engine.
• State Snapshots - Serializes the current story progress and variable values into a string for saving and restoring game sessions.
• Set-Based Operations - Tracks complex world states using set-based operations like unions, intersections, and membership queries.
• Script Compilation - Converts narrative scripts into a machine-readable JSON format for use in external game engines.
• Narrative Flow Previews - Provides a real-time environment to test narrative flow and branching logic immediately during the authoring process.
• Complex State Modeling - Allows combining multiple list families into a single variable to track location, status, and identity of game objects.
• Concurrent Narrative Contexts - Maintains multiple simultaneous narrative threads to handle background conversations and non-blocking interactions.
• Nested Choice Hierarchies - Creates hierarchical sub-choices where a primary decision unlocks a secondary set of responses.
• Dynamic State Set Updates - Adds, removes, or inverts groups of states within a list to update the game world dynamically.
• Narrative Flow Navigation - Directs the engine to move immediately to named points or specific lines within a narrative scene.
• Narrative Loop Patterns - Redirects flow back to previous options to allow repeated interaction until a specific condition is met.
• Non-Linear Narrative Workflows - Provides tools for organizing large-scale interactive scripts into manageable sections and files while maintaining complex flow.
• Parallel Narrative Threads - Maintains multiple simultaneous narrative threads to handle background events and non-blocking interactions.
• Random Number Generation - Generates pseudo-random integers within specified ranges to introduce chance-based events into the story.
• Random Number Generator Seeding - Allows developers to set a fixed random seed to ensure reproducible narrative outcomes during testing.
• Script Function Invocations - Enables external game code to run specific narrative functions and retrieve the resulting text and values.
• Concurrent State Flags - Uses lists as boolean sets to track multiple active flags for a single object simultaneously.
• Narrative Return Paths - Coordinates the execution of narrative segments that return the story flow to the original calling location.
• Source-to-Bytecode Compilers - Transforms raw narrative scripts into a structured JSON bytecode format to optimize runtime execution speed.
• Conditional Logic - Provides conditional control flow using if/else and switch statements to display content based on the current story state.
• Function Definitions - Supports the definition of reusable logic functions that perform calculations without interrupting the primary narrative flow.
• Logic Function Execution - Executes reusable logic blocks and calculations that accept parameters and return specific values during narrative playback.
• Multi-File Project Execution - Supports the organization of complex interactive stories across multiple source files using include statements.
• Selection Randomization - Implements randomization to select from text alternatives or generate random integers to create prose variety.
• Narrative Bytecode Compilation - Converts parsed story hierarchies into a lightweight JSON bytecode format to improve execution speed.
• Set-Based List Manipulation - Modifies complex list types using set operations like union, intersection, and inversion.
• Set Membership Operators - Checks if variables contain specific values or overlap with other sets using membership operators.
• Observer Patterns - Triggers external game logic callbacks automatically whenever specific narrative variables are modified.
• Narrative AST Parsing - Transforms raw narrative text files into a structured object hierarchy representing the original written layout.

Star history