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.