Forem: Hiroshi Tsubokawa

The out Parameter in Turbine: A Markdown-like Scripting Language

Hiroshi Tsubokawa — Thu, 23 Oct 2025 12:26:21 +0000

In previous posts, I’ve introduced some of the key syntax and features of Turbine, a Markdown-inspired scripting language.
This time, let’s look at one of its practical features, the out parameter, a mechanism for returning multiple values from a function, similar to how C and C++ handle it.

Why Do We Need an Out Parameter?

In Turbine, a function can only have one return value.

But sometimes, you want to return a main result and an additional status flag, for example, when you want to detect division by zero in a divide() function.

Many scripting languages, such as Python, can easily return multiple values using tuples:

def divide(a, b):
    if b == 0:
        return 0, False
    return a / b, True

result, ok = divide(10, 2)

That’s convenient and expressive.
However, in C or C++, a function can only return a single value, so developers typically use references or pointers to return additional results:

int divide(int a, int b, bool &ok)
{
    if (b == 0) {
        ok = false;
        return 0;
    }
    ok = true;
    return a / b;
}

Turbine follows this C/C++ style approach, but with a much simpler, Markdown-like syntax.

Writing an Out Parameter in Turbine

In Turbine, you declare an out parameter by prefixing it with &.

# divide(a int, b int, &ok bool) int
  if b == 0
    ok = false
    return 0
  ok = true
  return a / b

The function above performs integer division and sets ok to indicate success.

On the caller side, it looks like this:

# main(args vec{string}) int
  - ok bool
  - res = divide(10, 2, &ok)
  if ok
    print("result =", res)
  else
    print("divide by zero")
  return 0

Here, &ok means the variable ok is passed by reference, and the function writes its result back to it.

Design Philosophy

Turbine’s out parameter system is not just nostalgic imitation of C —
it’s designed to clearly separate the “main result” from auxiliary information.

Take the following example:

# parse_int(s string, &ok bool) int

If Turbine used tuple-style multiple returns (like (int, bool)), the caller would need to unpack both values every time, even if they only cared about one.
Instead, Turbine encourages a clear distinction:

Return value → the primary result
Out parameter → state, flag, or secondary information

This makes the code both cleaner and semantically clearer.

Explicitly Ignoring Outputs with `discard`

Out parameters cannot simply be omitted.
If you call a function with an out parameter but never use the variable afterward, Turbine will raise an error, it assumes you forgot to handle the result.

To intentionally ignore the output, you can use the special keyword discard:

# main(args vec{string}) int
  - result int = parse_int("123", &discard)
  print(result)
  return 0

The discard keyword lets you:

Skip creating an unnecessary variable
Avoid “unused output” errors
Clearly express that the result is intentionally ignored

This is especially convenient in lightweight scripts where you don’t need every auxiliary output.

Rules and Limitations

There are a few simple rules for out parameters in Turbine:

Only primitive types (bool, int, float) can be used with &
Reference types such as strings, containers (vec, map, etc.), and structs cannot be out parameters
At call time, you must pass either an existing variable or &discard

Because reference types are already passed by reference, you can modify them directly inside functions without &.

Summary

Turbine’s out parameter design is all about clarity and intent:

Use & to return extra results from a function
Callers must explicitly mark out arguments with &
Keeps the main return value semantically distinct
Detects unused out arguments at compile time
discard makes intentional ignoring explicit
Limited to primitive types for simplicity and safety

When you need to return just one extra piece of information, such as a success flag or minor result, Turbine’s out parameter is a clean and practical solution.

Learn More

Turbine is still in active development, and its syntax and semantics are evolving gradually.
You can check the progress and documentation here:

👉 GitHub (source)
👉 Project Docs

For Those Interested

If you’re into:

Language design and compiler implementation
Embeddable scripting languages that pair well with C/C++
Minimal, Markdown-inspired syntax

I’d love to hear your thoughts and feedback!
I’ll continue sharing updates and implementation notes as Turbine evolves.

Memory Management in Turbine: A Markdown-Inspired Scripting Language

Hiroshi Tsubokawa — Mon, 28 Jul 2025 16:36:12 +0000

Understanding Memory Management in Turbine

In previous posts, I introduced Turbine, a scripting language with Markdown-like syntax and some interesting features, like its enum system. Today, I’ll dive a bit deeper and walk through how memory is managed under the hood.

Turbine uses automatic memory management powered by garbage collection (GC). That means you don’t need to manually call free() like in C — memory cleanup is handled behind the scenes.

Still, if you’re interested in virtual machine (VM) internals or building your own language runtime, this post will give you an overview of how memory works in Turbine.

Primitive vs Reference Types

Turbine distinguishes between two kinds of values when it comes to memory management:

Primitive types (int, float, bool, etc.) are not managed by the GC.
Reference types (arrays, strings, user-defined structs, etc.) are managed by the GC.

Reference values are allocated on the heap, and what gets stored in VM registers or local variables is a reference (i.e. pointer) to those heap objects.

The garbage collector follows these references to determine which objects are still reachable and should stay alive.

Register-Based VM

Turbine’s virtual machine is register-based. Unlike stack-based VMs that use push and pop operations, Turbine instructions directly operate on register indices.

At compile time, the number of registers needed for a function is calculated — including all temporaries. This enables the VM to allocate just enough register space per function call, reducing overhead and avoiding unnecessary overlap between register lifetimes.

Each register can hold either a primitive value or a reference.

The GC inspects the registers and traces any reference-type values they contain, ensuring that only live heap objects stay around.

Precise Garbage Collection

Turbine implements a precise, tracing garbage collector, based on the classic mark-and-sweep algorithm.

Key characteristics:

The GC knows exactly which values are references and which are primitives.
It starts from roots (like global variables and VM registers), marks reachable objects, and sweeps the rest.
Fields within heap objects are recursively traced.

Since Turbine is statically typed, the compiler can simulate register types during code generation and record which registers hold references at each instruction. This allows the GC to consult a stack map-like table at runtime — no guessing needed.

Unlike conservative GCs (common in C-based runtimes), Turbine’s collector doesn’t need to keep ambiguous data "just in case it’s a pointer". Instead, it uses static type information to precisely identify which values to trace.

Example: GC in Action

> gc

# main(args vec{string}) int
  // Create a temporary vec
  for i, val in vec{11, 22, 42}
    print(2 * val)

  // The register holding the vec gets overwritten
  for i in 0..10
    print(2 * i)

  print("before ===============================")
  gc.print()
  // Temporary vec is now unreachable and should be collected
  gc.collect()
  print("after  ===============================")
  gc.print()

  return 0

In this example, a temporary vec is used in the first loop, and then its register is reused in the second loop, making the original reference unreachable.

Calling gc.collect() doesn’t immediately run the GC. Instead, it sets a flag in the VM, and garbage collection is triggered at the next safe point.
However, in most cases, it feels like GC runs instantly, so it behaves much like manual collection from the programmer’s perspective.

Summary

Turbine runs on a register-based virtual machine.
Reference types are managed by a precise mark-and-sweep GC.
Static type information enables accurate tracing without ambiguity.

As a developer, you don’t need to manually manage memory.

Links

Turbine is still under active development. Syntax and features are evolving, and I'm documenting the process as I go.

👉 GitHub (source)
👉 Project Docs

Interested?

If you're:

curious about designing a new language from scratch

looking for a small, embeddable scripting language that plays well with C/C++

into clean, Markdown-inspired syntax

…I’d love your thoughts and feedback!
More dev logs, code examples, and internals coming soon.

Enums in Turbine: More Than Just Constants

Hiroshi Tsubokawa — Mon, 05 May 2025 11:18:37 +0000

In my previous post, I introduced Turbine, a lightweight scripting language with a Markdown-like syntax. This time, I’d like to dive into a feature that stands out from conventional programming languages: Enums.

Moving Beyond Integer-Based Enums

In many languages, enums are used to represent states or flags by assigning consecutive integers or bit values (using things like iota() or auto()). A typical usage would be something like this in C++:

#include <iostream>

int main()
{
    enum class Color { red, green = 20, blue };
    Color r = Color::blue;

    switch(r)
    {
        case Color::red  : std::cout << "red\n";   break;
        case Color::green: std::cout << "green\n"; break;
        case Color::blue : std::cout << "blue\n";  break;
    }
}

Bit-shifting (like 1 << 0, 1 << 1, etc.) is often used for flag enums too, especially when working with combinations.

Turbine, however, takes a different approach: it removes the need to think about assigning specific numeric values altogether. Instead, you can directly associate meaningful data fields with each enum entry. That makes your enums more expressive and structured.

Here’s what it looks like in Turbine:

## Color enum
  : symbol , name    , rgba_index, bgra_index
  - R      , "red"   , 0         , 2
  - G      , "green" , 1         , 1
  - B      , "blue"  , 2         , 0
  - A      , "alpha" , 3         , 3

# main() int
  - r = Color.B
  print(r.name)
  - idx = r.bgra_index
  return 0

This format allows you to work with richer data—like color channels for different formats—without writing extra logic or switch statements. In essence, Turbine enums act like 2D tables where each row is a named data record.

Why Not Just Call It a Table?

Early in development, I originally called this feature a "table" instead of an "enum". The syntax even resembled Markdown tables. But several issues came up:

The | character conflicted with bitwise OR when writing constant expressions.
Explaining the feature took more effort than just calling it an "enum".
The term "table" was easily confused with "table types" in other languages.

Eventually, I chose to stick with the more familiar term: Enum. Describing it as a “2D enum” turns out to be surprisingly intuitive for most developers.

Looping Over Enum Entries

Sometimes, you need to loop over all enum values—like when building dropdown menus or defining configurable options. Turbine makes this very straightforward:

## Month enum
  : symbol , name         , num
  - Jan    , "January"    , 1
  - Feb    , "February"   , 2
  - Mar    , "March"      , 3
  - Apr    , "April"      , 4
  - May    , "May"        , 5
  - Jun    , "June"       , 6
  - Jul    , "July"       , 7
  - Aug    , "August"     , 8
  - Sep    , "September"  , 9
  - Oct    , "October"    , 10
  - Nov    , "November"   , 11
  - Dec    , "December"   , 12

# main(args vec{string}) int
  - month_menu = vec{"Select Month"}

  for m in Month
    vecpush(month_menu, m.name)

  // Use month_menu as the dropdown options
  // ...
  return 0

By treating enums as iterable collections, you can keep your UI and logic in sync without redundancy.

Enum Loops: A Syntax Exception

In Turbine, for loops normally expect an expression after in, like a range or a collection. But there's a special exception: Enums.

Instead of writing something like in Enum.all() or a built-in .values, Turbine allows you to simply write for val in Month. This improves readability and matches real-world use cases like UI building.

Yes, it bends the consistency of the syntax a bit, but the trade-off is worthwhile. In all other contexts, using just an enum type like Month without a field (e.g., Month.Jan) would result in a syntax error—so the parser treats this for loop form as a special case.

Summary

Turbine enums are more than just symbolic constants. They’re essentially collections of named records, shaped by their origin in table-based syntax. If you ever wanted to manage small tables of structured data inside a script, Turbine enums might be just what you’re looking for.

Learn More

Turbine is still under active development, and the syntax and features are evolving. You can follow along here:

👉 GitHub
👉 Documentation

Interested in Turbine?

Curious about language design?
Looking for a lightweight scripting language that pairs well with C/C++?
Love the idea of Markdown-style syntax?

If any of that sounds interesting, I'd love to hear from you!
Come join the discussion, share feedback, or just hang out with fellow language enthusiasts:

👉 Join the Turbine Discord

✨ Introducing Turbine – A Scripting Language for C and C++ Projects

Hiroshi Tsubokawa — Tue, 22 Apr 2025 12:49:44 +0000

Hello everyone! 👋

I'm excited to introduce Turbine, a small and focused scripting language designed to be embedded into C and C++ applications with minimal overhead.
It features a clean, Markdown-inspired syntax that keeps scripts easy to read and write—for both engineers and non-engineers alike.

Turbine is built around a single idea:

Keep things simple, explicit, and practical.

Turbine is designed for developers who want a lightweight, embeddable scripting tool that behaves predictably and integrates seamlessly with C or C++ codebases.

⚡️ Why Turbine?

If you’ve ever wanted to:

define behavior in plain-text config files
script parts of your application logic
allow lightweight user-defined automation
do all that without pulling in a heavyweight scripting runtime

…then Turbine might be just what you’re looking for.

Key features:

Minimal and readable syntax, loosely inspired by Markdown
No magic: no generics, no polymorphism, no complex runtime semantics
C99-compatible core, easily embeddable in both C and C++ projects
Familiar built-in containers: vec, set, map, queue, stack — inspired by C++ STL concepts, but much simpler
Scoped blocks for managing variable lifetime and organization

Turbine gives you just enough power — no more, no less.

What Does the Syntax Look Like?

Turbine is inspired by many ideas and feelings from Markdown.
However, its grammar is not fully compatible, and it follows its own style.

Hello World

The classic "Hello World" looks like this:

// Prints "Hello, World!" to the console.
# main(args vec{string}) int
  print("Hello, World!")
  return 0

main is the function called first by the virtual machine.
Function definitions are in the format: # function_name(parameter_name type, ...) return_type.
C++ style comments are used (// or /* ... */).
print() is a built-in function.

Summing Even Numbers

This example demonstrates working with vectors, loops, and basic conditional logic.

Define a simple function to process a vector.
Loop through a vector of integers and apply logic.
Use an if-statement to filter out even values.
Calculate the total sum of the filtered values.

# sum_even(numbers vec{int}) int
  - total = 0
  for val in numbers
    if val % 2 == 0
      total = total + val
  return total

# main() int
  - numbers = vec{1, 2, 3, 4, 5}
  - result = sum_even(numbers)
  print("Sum of even numbers:", result)
  return 0

🛠️ Project Status

Turbine is currently in early development.

It’s capable of running real scripts, comes with a test suite, and is already being embedded into native applications.

I'm now looking for:

early users to try things out
feedback from C/C++ developers
contributors who are excited to help shape the language

🚀 Getting Started

GitHub repository:

👉 https://github.com/tsubo164/turbine

Documentation:
👉 Turbine Programming Language

To build it, all you need is a C99-compatible compiler (e.g. gcc, clang, tcc)

No external dependencies. No build system hell.

💬 Join the Community

I’d love to hear from you!

Join our Discord to chat, give feedback, or follow development:

👉 [https://discord.gg/Q6pABVW3]

Thanks for reading!

I hope Turbine becomes a useful tool in your C or C++ toolkit.

Let’s build something simple, together. ⚙️

🧠 P.S.

If you’ve ever wished for a scripting language that feels like a natural extension of C or C++ — with familiar containers and no surprises — give Turbine a try.

Forem: Hiroshi Tsubokawa

The out Parameter in Turbine: A Markdown-like Scripting Language

Why Do We Need an Out Parameter?

Writing an Out Parameter in Turbine

Design Philosophy

Explicitly Ignoring Outputs with discard

Rules and Limitations

Summary

Learn More

For Those Interested

Memory Management in Turbine: A Markdown-Inspired Scripting Language

Understanding Memory Management in Turbine

Primitive vs Reference Types

Register-Based VM

Precise Garbage Collection

Example: GC in Action

Summary

Links

Interested?

Enums in Turbine: More Than Just Constants

Moving Beyond Integer-Based Enums

Why Not Just Call It a Table?

Looping Over Enum Entries

Enum Loops: A Syntax Exception

Summary

Learn More

Interested in Turbine?

✨ Introducing Turbine – A Scripting Language for C and C++ Projects

⚡️ Why Turbine?

What Does the Syntax Look Like?

Hello World

Summing Even Numbers

🛠️ Project Status

🚀 Getting Started

💬 Join the Community

🧠 P.S.

Explicitly Ignoring Outputs with `discard`