MiniScript 2 Preview Builds is Here!!

#miniscript #minimicro #miniscript2 #language

As someone who primarily lives in Go and has a deep respect for strongly-typed, explicit systems, I've always appreciated minimalist languages that prioritize clarity over complexity. MiniScript has been one of those under-the-radar tools — simple, embeddable, and focused on being genuinely pleasant to use. Joe Strout's announcement of MiniScript 2 preview builds caught my attention right away, and after going through the details, I'm excited about the direction.

Here's my honest take, filtered through the lens of someone who values Go's pragmatism and Rust's emphasis on safety and correctness.

Why This Release Matters

MiniScript was designed to be minimal yet powerful. Version 2 stays true to that philosophy while delivering meaningful upgrades: significantly better performance (aiming for Python-level speeds) and targeted language improvements that fix real pain points without bloating the language. This kind of disciplined evolution is exactly what I look for.

The Changes I Appreciate Most

1. First-Class `error` Type

This might be my favorite part of the release.

In Go, explicit error handling is a fundamental principle — errors are values, and you deal with them directly. MiniScript 1.x's error handling felt loose and string-based. The new dedicated error type brings a much-needed improvement. Most operations on errors will crash the program (which is usually the safe default), while still allowing deliberate inspection and handling when needed.

It's not heavyweight exceptions with try-catch blocks, and I'm glad for that. This approach feels aligned with Go's philosophy: make errors visible and explicit without unnecessary ceremony. As a Go developer, this change immediately feels natural and trustworthy.

2. Frozen (Immutable) Maps and Lists

Immutability is one of those concepts I've come to love, especially after seeing how Rust handles ownership and borrowing to eliminate entire categories of bugs at compile time.

Even though I haven't fully tackled Rust yet (its learning curve is no joke), the ideas have strongly influenced how I think about code. MiniScript 2's ability to freeze lists and maps is a fantastic addition. Once frozen, they become truly immutable — any attempt to modify them results in a clear runtime error. Core functions like version now return frozen structures by default.

This is a small but powerful feature that adds reliability, especially when passing data around or using collections as keys. It's the kind of safety I wish more scripting languages embraced more aggressively.

3. Function Notes and the `info` Intrinsic

Great documentation can make or break the experience of using a library. I rely heavily on well-documented APIs in tools like Godot — clear, accessible docs turn exploration into productivity.

MiniScript 2 lets developers add a documentation string as the first constant string inside a function. The new info(@func) intrinsic then exposes rich metadata: the note, parameters, and more. This makes libraries and modules far more self-documenting and discoverable.

For someone who jumps between languages and ecosystems, this feature lowers the friction of adopting community code. It's thoughtful design that respects the user's time.

Personal Reflections

Spending most of my time in Go has made me quite opinionated: I favor explicitness, simplicity, and systems that help me avoid mistakes. Rust's approach to safety and immutability continues to inspire me, even if I'm still working up the courage to master its borrow checker.

MiniScript 2 doesn't try to become a full systems language — and that restraint is part of its charm. The new error handling, immutable collections, and built-in documentation support feel like natural extensions that make the language more solid for real use cases without losing its lightweight, embeddable nature.

It's a reminder that the best language improvements often come from refining the core rather than chasing every shiny feature.

Personal Take
These days I had stepped away from working and making games on Mini Micro and MiniScript because life got busy. But now I'm trying to come back to it. I might start making new games in Mini Micro and explore it more deeply.

I'm personally very excited for Mini Micro 2. As soon as it releases, it might become my No.1 choice for 2D games. Right now Mini Micro is already my No.2 choice for 2D games (No.1 is Godot because it gets me really hooked). The only thing holding Mini Micro back for me is the lack of built-in shader support and some other advanced features that modern engines provide.

But till date, for beginners I will strongly suggest everyone to try out Mini Micro — one of the best engines out there for learning and rapid prototyping.

Try MiniScript 2 Yourself

If you enjoy clean, embeddable scripting languages — especially if you appreciate Go-like pragmatism or Rust-inspired safety — this is a great time to explore:

Preview builds: GitHub Releases
Detailed language changes: LANGUAGE_CHANGES.md
Official site and docs: miniscript.org

I'm looking forward to seeing what the community builds with these upgrades, particularly in games, tools, and learning projects.

If you've tried the MiniScript 2 preview, what are your thoughts on the new error handling or frozen collections? Especially interested if you also come from Go, Rust, or other systems languages. Drop your thoughts in the comments or on Discord.